diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simatktsy/tests/src/ccsatsendsmsfu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simatktsy/tests/src/ccsatsendsmsfu.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1916 @@ +// 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 SendSMS in the SAT. +*/ + +#include +#include + +#include +#include + +#include +#include +#include +//#include "csatnotificationstsy.h" +#include "ccsatsendsmsfu.h" + +const TUint8 KTestPCmdNumber = 1; +_LIT8(KDialingNumberString8,"112233445566778"); +_LIT16(KDialingNumberString16,"112233445566778"); + + +CTestSuite* CCSatSendSMSFU::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + + ADD_TEST_STEP_ISO_CPP(CCSatSendSMSFU, TestNotifySendSmPCmd0001L); + ADD_TEST_STEP_ISO_CPP(CCSatSendSMSFU, TestNotifySendSmPCmd0002L); + ADD_TEST_STEP_ISO_CPP(CCSatSendSMSFU, TestNotifySendSmPCmd0004L); + + END_SUITE; + } + +// +// Actual test cases +// + +/** +@SYMTestCaseID BA-CSAT-SSMS-SNSSMPC-0001 +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test support in CSAT for RSat::NotifySendSmPCmd +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySendSmPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSendSMSFU::TestNotifySendSmPCmd0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of RSat::NotifySendSmPCmd + //------------------------------------------------------------------------- + // Run some of test sequences listed in 3GPP TS 31.124 clause 27.22.4.10 "SEND SHORT MESSAGE" + DoPositiveNotifySendSmPCmdTestL(ETestSequence14); + DoPositiveNotifySendSmPCmdTestL(ETestSequence15); + DoPositiveNotifySendSmPCmdTestL(ETestSequence16); + DoPositiveNotifySendSmPCmdTestL(ETestSequence17); + DoPositiveNotifySendSmPCmdTestL(ETestSequence18); + DoPositiveNotifySendSmPCmdTestL(ETestSequence31A); + DoPositiveNotifySendSmPCmdTestL(ETestSequence31B); + DoPositiveNotifySendSmPCmdTestL(ETestSequence32A); + DoPositiveNotifySendSmPCmdTestL(ETestSequence32B); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RSat::NotifySendSmPCmd + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + // Create unsolicted "SEND SHORT MESSAGE" + TTpdu tpdu; + MockCompleteSendSmPCmdL(tpdu,ETestUnsolictedCompletion); + + // Prime Mock for forthcoming "TERMINAL RESPONSE" that is invoked internally by SAT TSY + MockPrimeSendSmTerminalResponseL(ETestUnsolictedCompletion); + + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST F: Coverage test(s) for RSat::NotifySendSmPCmd + //------------------------------------------------------------------------- + DoPositiveNotifySendSmPCmdTestL(ETestMissingAddressType); + DoPositiveNotifySendSmPCmdTestL(ETestMissingDiallingNumber); + DoPositiveNotifySendSmPCmdTestL(ETestSmsCommand); + DoPositiveNotifySendSmPCmdTestL(ETestRelativeVPF); + DoPositiveNotifySendSmPCmdTestL(ETestEnchancedVPF); + DoPositiveNotifySendSmPCmdTestL(ETestAbsoluteVPF); + DoPositiveNotifySendSmPCmdTestL(ETestRelativeVPFPacked); + DoPositiveNotifySendSmPCmdTestL(ETestEnchancedVPFPacked); + + DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsCommand); + DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit8bit); + DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit7bit); + DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit8bitPacked); + DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit7bitPacked); + DoNegativeNotifySendSmPCmdTestL(ETestMissingSmsTpdu); + + DoTestTerminalResponseL(); + + DoPositiveNotifySendSmPCmdTestL(ETestAbsoluteVPFPacked); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + tpdu.Zero(); + MockPrimeSendSmPCmdL(tpdu,ETestSequence11,KErrUnknown); + + TRequestStatus reqStatus; + + RSat::TSendSmV1 sendSm; + RSat::TSendSmV1Pckg sendSmPckg(sendSm); + iSat.NotifySendSmPCmd(reqStatus,sendSmPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrUnknown, reqStatus.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(this); + + } + + +/** +@SYMTestCaseID BA-CSAT-SSMS-SNSSMPC-0002 +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test support in CSAT for cancelling of RSat::NotifySendSmPCmd +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RSat::NotifySendSmPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSendSMSFU::TestNotifySendSmPCmd0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + // tell Mock about forthcoming RSat::NotifySendSmPCmd + const TUint8 KPcmdCode = KSendShortMessage; + const TPckgC KPcmdCodePckg(KPcmdCode); + + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,KPcmdCodePckg); + + //------------------------------------------------------------------------- + // Test cancelling of RSat::NotifySendSmPCmd + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + + RSat::TSendSmV1 sendSm; + RSat::TSendSmV1Pckg sendSmPckg(sendSm); + iSat.NotifySendSmPCmd(reqStatus,sendSmPckg); + iSat.CancelAsyncRequest(ESatNotifySendSmPCmd); + ASSERT_EQUALS(KErrCancel, reqStatus.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(this); + + } + +/** +@SYMTestCaseID BA-CSAT-SSMS-SNSSMPC-0004 +@SYMPREQ 1780 +@SYMComponent telephony_csat +@SYMTestCaseDesc Test support in CSAT for multiple client requests to RSat::NotifySendSmPCmd +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RSat::NotifySendSmPCmd +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCSatSendSMSFU::TestNotifySendSmPCmd0004L() + { + // Note: Most likely this test should be fixed. + // Currently *all simultenious* RSat::NotifyXXXXPCmd() requests complete + // with KErrNone when corresponding proactive command arrives succesfully. + // That's the problem because once a RSat client gets a proactive command + // it should reply with appropriate "TERMINAL RESPONSE" after processing it. + // So if there are *two or more* independant clients listening for the same + // proactive command then *two or more* "TERMINAL RESPONSE"s for that command + // are likely. Such behaviour seems to be erroneous because once a SIM application + // has issued a proactive command it would expect a *single* "TERMINAL RESPONSE" + // in reply but not two or more. + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(telServer2,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RSat sat2; + ret = sat2.Open(phone2); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(sat2); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RSat::NotifySendSmPCmd + //------------------------------------------------------------------------- + + // Prime Mock with "SEND SHORT MESSAGE" proactive command + TTpdu tpdu; + MockPrimeSendSmPCmdL(tpdu, ETestSequence11); + + // Invoke 1-st client RSat::NotifySendSmPCmd() + TRequestStatus reqStatus1; + + RSat::TSendSmV1 sendSm1; + RSat::TSendSmV1Pckg sendSmPckg1(sendSm1); + iSat.NotifySendSmPCmd(reqStatus1,sendSmPckg1); + + // Invoke 2-nd client RSat::NotifySendSmPCmd() + TRequestStatus reqStatus2; + RSat::TSendSmV1 sendSm2; + RSat::TSendSmV1Pckg sendSmPckg2(sendSm2); + sat2.NotifySendSmPCmd(reqStatus2,sendSmPckg2); + + User::WaitForRequest(reqStatus1); + User::WaitForRequest(reqStatus2); + + // Check both results + ASSERT_EQUALS(KErrNone, reqStatus1.Int()); + ASSERT_EQUALS(KErrNone, reqStatus2.Int()); // KErrNone or KErrServerBusy ? See the note at the top. + ASSERT_EQUALS(KTestPCmdNumber, sendSm1.PCmdNumber()); + ASSERT_EQUALS(KTestPCmdNumber, sendSm2.PCmdNumber()); + ASSERT_EQUALS(sendSm1.iAlphaId.iStatus, ExpectedAlphaIdStatus(ETestSequence11)); + ASSERT_EQUALS(sendSm2.iAlphaId.iStatus, ExpectedAlphaIdStatus(ETestSequence11)); + ASSERT_TRUE(sendSm1.iAlphaId.iAlphaId == ExpectedAlphaId(ETestSequence11)); + ASSERT_TRUE(sendSm2.iAlphaId.iAlphaId == ExpectedAlphaId(ETestSequence11)); + ASSERT_EQUALS(sendSm1.iAddress.iTypeOfNumber, ExpectedTypeOfNumber(ETestSequence11)); + ASSERT_EQUALS(sendSm2.iAddress.iTypeOfNumber, ExpectedTypeOfNumber(ETestSequence11)); + ASSERT_EQUALS(sendSm1.iAddress.iNumberPlan, ExpectedNumberPlan(ETestSequence11)); + ASSERT_EQUALS(sendSm2.iAddress.iNumberPlan, ExpectedNumberPlan(ETestSequence11)); + ASSERT_TRUE(sendSm1.iAddress.iTelNumber == KDialingNumberString16); + ASSERT_TRUE(sendSm2.iAddress.iTelNumber == KDialingNumberString16); + ASSERT_TRUE(sendSm1.iSmsTpdu == tpdu); + ASSERT_TRUE(sendSm2.iSmsTpdu == tpdu); + + // Prime MOCK with appropriate "TERMINAL RESPONSE" + RSat::TSendSmRspV1 rsp; + RSat::TSendSmRspV1Pckg rspPckg(rsp); + FillResponse(rsp,ETestSequence11); + MockPrimeSendSmTerminalResponseL(ETestSequence11,rsp); + + // Invoke 1-st RSat:TerminalRsp + TRequestStatus rspStatus1; + iSat.TerminalRsp(rspStatus1,RSat::ESendSm,rspPckg); + User::WaitForRequest(rspStatus1); + ASSERT_EQUALS(KErrNone, rspStatus1.Int()); + + // Prime MOCK once again with "TERMINAL RESPONSE" + MockPrimeSendSmTerminalResponseL(ETestSequence11,rsp); + + // Invoke 2-nd RSat:TerminalRsp + TRequestStatus rspStatus2; + sat2.TerminalRsp(rspStatus2,RSat::ESendSm,rspPckg); + User::WaitForRequest(rspStatus2); + ASSERT_EQUALS(KErrNone, rspStatus2.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(4, this); // sat2, phone2, telServer2, this + + } + +// *************************** +// * TLV tags used for testing +// *************************** +#if 1 +// TLV tags without CR bit +const TUint8 KTestCommandDetailsTag = KTlvCommandDetailsTag; +const TUint8 KTestDeviceIdentityTag = KTlvDeviceIdentityTag; +const TUint8 KTestAlphaIdentifierTag = KTlvAlphaIdentifierTag; +const TUint8 KTestAddressTag = KTlvAddressTag; +const TUint8 KTestSmsTpduTag = KTlvSmsTpduTag; +const TUint8 KTestResultTag = KTlvResultTag; +const TUint8 KTestIconIdentifierTag = KTlvIconIdentifierTag; +#else +// TLV tags with CR (Comprehension Required) bit set. +// It is not quite clear how exacly it should be used in "TERMINAL RESPONSE" +// but current SAT TSY implementation never sets it there for tags other +// than "command details" though terminal responses listed in TS 31.124 have it set +// for all tags. Is that a defect ?? +const TUint8 KTestCommandDetailsTag = (KTlvCommandDetailsTag | KTagCrMask); +const TUint8 KTestDeviceIdentityTag = (KTlvDeviceIdentityTag | KTagCrMask); +const TUint8 KTestAlphaIdentifierTag = (KTlvAlphaIdentifierTag | KTagCrMask); +const TUint8 KTestAddressTag = (KTlvAddressTag | KTagCrMask); +const TUint8 KTestSmsTpduTag = (KTlvSmsTpduTag | KTagCrMask); +const TUint8 KTestResultTag = (KTlvResultTag | KTagCrMask); +const TUint8 KTestIconIdentifierTag = (KTlvIconIdentifierTag | KTagCrMask); +#endif + +// ****************************** +// * TLV values used for testing +// ****************************** + +// Type of address, see ETSI TS 102 223 (v8.1.0) clause 8.1 +// Possible TON (i.e. "Type Of Number") values: +// 0x00 (000) - Unknown +// 0x01 (001) - International Number +// 0x02 (010) - National Number +// 0x03 (011) - Network Specific Number +// the below values are defined in 3GPP TS 23.040 V8.2.0 +// 0x04 (100) Subscriber number +// 0x05 (101) Alphanumeric, (coded according to 3GPP TS 23.038 [9] GSM 7-bit default alphabet) +// 0x06 (110) Abbreviated number +// 0x07 (111) Reserved for extension + +// Possible NPI (i.e. "Numbering Plan Identification") values: +// 0x00 (0000) - Unknown +// 0x01 (0001) - ISDN/telephony numbering plan (ITU-T Recommendations E.164 and E.163) +// 0x03 (0011) - Data numbering plan (ITU-T Recommendation X.121) +// 0x04 (0100) - Telex numbering plan (ITU-T Recommendation F.69) +// 0x09 (1001) - Private numbering plan +// 0x0F (1111) - Reserved for extension +// the below values are defined in 3GPP TS 23.040 V8.2.0 +// 0x05 (0101) Service Centre Specific plan +// 0x06 (0110) Service Centre Specific plan +// 0x08 (1000) National numbering plan +// 0x0A (1010) ERMES numbering plan (ETSI DE/PS 3 01-3) +const TUint8 KTestTypeOfAddress = (0x80 | (0x01 << 4) | 0x01); // International number + ISDN/telephony numbering plan + +// Icon identifier (a number of a record in EFimg) +const TUint8 KTestIconIdentifier = 1; + +// TP-Protocol-Identifier (TP-PID) values, see 3GPP TS 23.040 V8.2.0, clause 9.2.3.9 +// 0x40 (01000000) Short Message Type 0 +// 0x41 (01000001) Replace Short Message Type 1 +// 0x42 (01000010) Replace Short Message Type 2 +// 0x43 (01000011) Replace Short Message Type 3 +// 0x44 (01000100) Replace Short Message Type 4 +// 0x45 (01000101) Replace Short Message Type 5 +// 0x46 (01000110) Replace Short Message Type 6 +// 0x46 (01000111) Replace Short Message Type 7 +// 0x5E (01011110) Enhanced Message Service (Obsolete) +// 0x5F (01011111) Return Call Message +// 0x7C (01111100) ANSI-136 R-DATA +// 0x7D (01111101) ME Data download +// 0x7E (01111110) ME De-personalization Short Message +// 0x7F (01111111) (U)SIM Data download +const TUint8 KShortMessageType0 = 0x40; //Short message type 0 + + +//********************** +// Strings used in tests +//********************** + +_LIT8(KDestinationAddressString8,"012345678"); +_LIT8(KShortDestinationAddressString8,"01"); +_LIT8(KTestMessageString8,"Test Message"); +_LIT8(KSendSmString8,"Send SM"); +_LIT16(KSendSmString16,"Send SM"); +_LIT8(KShortMessageString8,"Short Message"); +_LIT16(KShortMessageString16,"Short Message"); +_LIT8(KNoIconString8,"NO ICON"); +_LIT16(KNoIconString16,"NO ICON"); + +// GSM7 coded "Short Message" +_LIT8(KShortMessageStringGSM7,"\x53\xF4\x5B\x4E\x07\x35\xCB\xF3\x79\xF8\x5C\x06"); + +// GSM7 encoded "The address data object holds the RP_Destination_Address" +_LIT8(KSequence14AlphaString8, +"\x54\x68\x65\x20\x61\x64\x64\x72\x65\x73\x73\x20\x64\x61\x74\x61\ +\x20\x6F\x62\x6A\x65\x63\x74\x20\x68\x6F\x6C\x64\x73\x20\x74\x68\ +\x65\x20\x52\x50\x11\x44\x65\x73\x74\x69\x6E\x61\x74\x69\x6F\x6E\ +\x11\x41\x64\x64\x72\x65\x73\x73"); + +_LIT(KSequence14AlphaString16, +"The address data object holds the RP_Destination_Address"); + +_LIT8(KSequence15AlphaString8, +"The address data object holds the RP Destination Address"); + +_LIT(KSequence15AlphaString16, +"The address data object holds the RP Destination Address"); + +_LIT8(KSequence16AlphaString8, +"Two types are defined: - A short message to be sent to the network in an \ +SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can \ +be passed transparently; - A short message to be sent to the network in an \ +SMS-SUBMIT "); + +_LIT(KSequence16AlphaString16, +"Two types are defined: - A short message to be sent to the network in an \ +SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can \ +be passed transparently; - A short message to be sent to the network in an \ +SMS-SUBMIT "); + +_LIT8(KLongUserDataString8, +"Two types are defined: - A short message to be sent to the network in an \ +SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can \ +be passed transp"); + +// GSM7 encoded K160CharsString +//"Two types are defined: - A short message to be sent to the network in an " +//"SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can " +//"be passed transp" +_LIT8(KLongUserDataStringGSM7, +"\xD4\xFB\x1B\x44\xCF\xC3\xCB\x73\x50\x58\x5E\x06\ +\x91\xCB\xE6\xB4\xBB\x4C\xD6\x81\x5A\xA0\x20\x68\ +\x8E\x7E\xCB\xE9\xA0\x76\x79\x3E\x0F\x9F\xCB\x20\ +\xFA\x1B\x24\x2E\x83\xE6\x65\x37\x1D\x44\x7F\x83\ +\xE8\xE8\x32\xC8\x5D\xA6\xDF\xDF\xF2\x35\x28\xED\ +\x06\x85\xDD\xA0\x69\x73\xDA\x9A\x56\x85\xCD\x24\ +\x15\xD4\x2E\xCF\xE7\xE1\x73\x99\x05\x7A\xCB\x41\ +\x61\x37\x68\xDA\x9C\xB6\x86\xCF\x66\x33\xE8\x24\ +\x82\xDA\xE5\xF9\x3C\x7C\x2E\xB3\x40\x77\x74\x59\ +\x5E\x06\xD1\xD1\x65\x50\x7D\x5E\x96\x83\xC8\x61\ +\x7A\x18\x34\x0E\xBB\x41\xE2\x32\x08\x1E\x9E\xCF\ +\xCB\x64\x10\x5D\x1E\x76\xCF\xE1"); + +_LIT8(KSingleSpaceUserData8," "); + +// ********************* +// Below TPDUs are taken from 3GPP TS 31.124 (see SMS-PP (SEND SHORT MESSAGE) +// codings for each test sequence where command qualifier is set to "packing required") +// The only difference is that MR values (the 2-nd byte) are "0" instead of "1" as +// in the original document. +// ********************* + +_LIT8(KSequence12ExpectedTpdu, +"\x01\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\x07\xD3\xB2\x9B\x0C\x9A\x36\x01"); + +_LIT8(KSequence14ExpectedTpdu, +"\x01\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\ +\xA0\xD4\xFB\x1B\x44\xCF\xC3\xCB\x73\x50\x58\x5E\ +\x06\x91\xCB\xE6\xB4\xBB\x4C\xD6\x81\x5A\xA0\x20\ +\x68\x8E\x7E\xCB\xE9\xA0\x76\x79\x3E\x0F\x9F\xCB\ +\x20\xFA\x1B\x24\x2E\x83\xE6\x65\x37\x1D\x44\x7F\ +\x83\xE8\xE8\x32\xC8\x5D\xA6\xDF\xDF\xF2\x35\x28\ +\xED\x06\x85\xDD\xA0\x69\x73\xDA\x9A\x56\x85\xCD\ +\x24\x15\xD4\x2E\xCF\xE7\xE1\x73\x99\x05\x7A\xCB\ +\x41\x61\x37\x68\xDA\x9C\xB6\x86\xCF\x66\x33\xE8\ +\x24\x82\xDA\xE5\xF9\x3C\x7C\x2E\xB3\x40\x77\x74\ +\x59\x5E\x06\xD1\xD1\x65\x50\x7D\x5E\x96\x83\xC8\ +\x61\x7A\x18\x34\x0E\xBB\x41\xE2\x32\x08\x1E\x9E\ +\xCF\xCB\x64\x10\x5D\x1E\x76\xCF\xE1"); + +// ************************* +// Fake TP-VP values used in +// ************************* +_LIT8(KFakeRelativeValidityValue,"\x00"); +_LIT8(KFakeAbsoluteOrEnchancedValidityValue,"\x00\x00\x00\x00\x00\x00\x00"); + +// ********************* +// below 3 TPDUs are made of KSequence12ExpectedTpdu combined with +// KFakeRelativeValidityValue and KFakeAbsoluteOrEnchancedValidityValue appropriately +// Once the above strings are changed the below should be changed too +// ********************* +_LIT8(KTestRelativeVPFPackedExpectedTpdu, +"\x11\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\x00\x07\xD3\xB2\x9B\x0C\x9A\x36\x01"); + +_LIT8(KTestEnchancedVPFPackedExpectedTpdu, +"\x09\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\x00\x00\x00\x00\x00\x00\x00\x07\xD3\xB2\x9B\x0C\x9A\x36\x01"); + +_LIT8(KTestAbsoluteVPFPackedExpectedTpdu, +"\x19\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\x00\x00\x00\x00\x00\x00\x00\x07\xD3\xB2\x9B\x0C\x9A\x36\x01"); + +/** + * Executes "positive" RSat::NotifySendSmPCmd() test identified by aTC + * @param aTC testcase identifier + */ +void CCSatSendSMSFU::DoPositiveNotifySendSmPCmdTestL(TSendSmTC aTC) + { + // Prime Mock with appopriate "SEND SHORT MESSAGE" proactive command + TTpdu tpdu; + MockPrimeSendSmPCmdL(tpdu, aTC); + + // Invoke RSat::NotifySendSmPCmd() + TRequestStatus reqStatus; + + RSat::TSendSmV1 sendSm; + RSat::TSendSmV1Pckg sendSmPckg(sendSm); + iSat.NotifySendSmPCmd(reqStatus,sendSmPckg); + User::WaitForRequest(reqStatus); + + // Check the result + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + ASSERT_EQUALS(KTestPCmdNumber, sendSm.PCmdNumber()); + if(AlphaIdIsUsed(aTC)) + { + ASSERT_EQUALS(sendSm.iAlphaId.iStatus, ExpectedAlphaIdStatus(aTC)); + ASSERT_TRUE(sendSm.iAlphaId.iAlphaId == ExpectedAlphaId(aTC)); + } + else + { + ASSERT_EQUALS(RSat::EAlphaIdNotPresent, sendSm.iAlphaId.iStatus); + } + ASSERT_EQUALS(sendSm.iAddress.iTypeOfNumber, ExpectedTypeOfNumber(aTC)); + ASSERT_EQUALS(sendSm.iAddress.iNumberPlan, ExpectedNumberPlan(aTC)); + if(CompleteAddressIsUsed(aTC)) + { + ASSERT_TRUE(sendSm.iAddress.iTelNumber == KDialingNumberString16); + } + if(IsIconRelatedTC(aTC)) + { + ASSERT_EQUALS(sendSm.iIconId.iQualifier, ExpectedIconQualifier(aTC)); + ASSERT_EQUALS(sendSm.iIconId.iIdentifier, KTestIconIdentifier); + } + if(PackingIsUsed(aTC)) + { + ASSERT_TRUE(sendSm.iSmsTpdu == ExpectedTpdu(aTC)); + } + else + { + ASSERT_TRUE(sendSm.iSmsTpdu == tpdu); + } + + // Prime MOCK with appropriate "TERMINAL RESPONSE" + RSat::TSendSmRspV1 rsp; + FillResponse(rsp,aTC); + MockPrimeSendSmTerminalResponseL(aTC,rsp); + + // Invoke RSat::TerminalRsp + RSat::TSendSmRspV1Pckg rspPckg(rsp); + TerminalResponseL(RSat::ESendSm,rspPckg); + } + +/** + * Executes "negative" RSat::NotifySendSmPCmd() test identified by aTC + * @param aTC testcase identifier + */ +void CCSatSendSMSFU::DoNegativeNotifySendSmPCmdTestL(TSendSmTC aTC) + { + // Tell Mock to issue "SEND SHORT MESSAGE" with some corrupted data + TTpdu tpdu; + MockPrimeSendSmPCmdL(tpdu, aTC); + + // Prime Mock with appropriate "TERMINAL RESPONSE" because + // in case of error SAT TSY inokes it internally + MockPrimeSendSmTerminalResponseL(aTC); + + // Call RSat::NotifySendSmPCmd() + TRequestStatus reqStatus; + + RSat::TSendSmV1 sendSm; + RSat::TSendSmV1Pckg sendSmPckg(sendSm); + iSat.NotifySendSmPCmd(reqStatus,sendSmPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrCorrupt, reqStatus.Int()); + } + +/** + * Tests all possible "TERMINAL RESPONSE" cases. + * API should return KErrNone for all valid responses and KErrCorrupt + * for those that can not be used with "SEND SHORT MESSAGE" command + */ +void CCSatSendSMSFU::DoTestTerminalResponseL() + { + static const struct + { + RSat::TPCmdResult iGeneralResult; + RSat::TAdditionalInfoType iInfoType; + TBool iIntentionallyOmmitAdditionalInfo; + TUint8 iAdditionalInfo; + TInt iExpectedResult; + } + KResponsesToTest[] = + { + { + // 0x01 - Command performed with partial comprehension; + RSat::KPartialComprehension, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x02 - Command performed, with missing information; + RSat::KMissingInformation, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x03 - REFRESH performed with additional EFs read; + RSat::KRefreshAdditionEFRead, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x04 - Command performed successfully, but requested icon could not be displayed; + RSat::KSuccessRequestedIconNotDisplayed, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x05 - Command performed, but modified by call control by NAA; + RSat::KModifiedByCallControl, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x06 - Command performed successfully, limited service; + RSat::KSuccessLimitedService, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x07 - Command performed with modification; + RSat::KPerformedWithModifications, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x08 - REFRESH performed but indicated NAA was not active; + RSat::KRefreshUSIMNotActive, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x09 - Command performed successfully, tone not played; + RSat::KPlayTonePerformedSuccessfully, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x10 - Proactive UICC session terminated by the user; + RSat::KPSessionTerminatedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x11 - Backward move in the proactive UICC session requested by the user; + RSat::KBackwardModeRequestedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x12 - No response from user; + RSat::KNoResponseFromUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x13 - Help information required by the user; + RSat::KHelpRequestedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x14 - reserved for GSM/3G. + RSat::KUssdTransactionTerminatedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x20 - terminal currently unable to process command; + RSat::KMeUnableToProcessCmd, + RSat::KMeProblem, + EFalse, + 0, + KErrNone + }, + { + // 0x20 without additional information (erroneous) + RSat::KMeUnableToProcessCmd, + RSat::KMeProblem, + ETrue, // Intentional error ! + 0, + KErrCorrupt + }, + { + // 0x21 - Network currently unable to process command; + RSat::KNetworkUnableToProcessCmd, + RSat::KSatNetworkErrorInfo, + EFalse, + 0, + KErrCorrupt + }, + { + // 0x21 without additional information (erroneous) + RSat::KNetworkUnableToProcessCmd, + RSat::KSatNetworkErrorInfo, + ETrue, // Intentional error ! + 0, + KErrCorrupt + }, + { + // 0x22 - User did not accept the proactive command; + RSat::KPCmdNotAcceptedByUser, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x23 - User cleared down call before connection or network release; + RSat::KCallClearedBeforeConnectionOrReleased, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x24 - Action in contradiction with the current timer state; + RSat::KContradictionWithTimerState, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x25 - Interaction with call control by NAA, temporary problem; + RSat::KInteractionWithCCTemporaryError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x26 - Launch browser generic error code; + RSat::KLaunchBrowserError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x26 without additional information (erroneous) + RSat::KLaunchBrowserError, + RSat::KMeProblem, + ETrue, // Intentional error ! + 0, + KErrCorrupt + }, + { + // 0x27 - MMS temporary problem. + RSat::KMMSTemporaryProblem, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x30 - Command beyond terminal's capabilities; + RSat::KCmdBeyondMeCapabilities, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x31 - Command type not understood by terminal; + RSat::KCmdTypeNotUnderstood, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x32 - Command data not understood by terminal; + RSat::KCmdDataNotUnderstood, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x33 - Command number not known by terminal; + RSat::KCmdNumberNotKnown, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x34 - reserved for GSM/3G; + RSat::KSsReturnError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x35 - reserved for GSM/3G; + RSat::KSmsRpError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrNone + }, + { + // 0x36 - Error, required values are missing; + RSat::KErrorRequiredValuesMissing, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x37 - reserved for GSM/3G; + RSat::KUssdReturnError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x38 - MultipleCard commands error; + RSat::KMultipleCardCmdsError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x38 without additional information (erroneous) + RSat::KMultipleCardCmdsError, + RSat::KMeProblem, + ETrue, // Intentional error + 0, + KErrCorrupt + }, + { + // 0x39 - Interaction with call control by NAA, permanent problem; + RSat::KInteractionWithCCPermanentError, + RSat::KControlInteraction, + EFalse, + 0, + KErrNone + }, + { + // 0x39 without additional information (erroneous) + RSat::KInteractionWithCCPermanentError, + RSat::KControlInteraction, + ETrue, // Intentional error + 0, + KErrCorrupt + }, + { + // 0x3A - Bearer Independent Protocol error; + RSat::KBearerIndepProtocolError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x3A without additional information (erroneous) + RSat::KBearerIndepProtocolError, + RSat::KMeProblem, + ETrue, // Intentional error + 0, + KErrCorrupt + }, + { + // 0x3B - Access Technology unable to process command; + RSat::KAccessTechUnableProcessCmd, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x3C - Frames error; + RSat::KFramesError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x3C without additional information (erroneous) + RSat::KFramesError, + RSat::KMeProblem, + ETrue, // Intentional error + 0, + KErrCorrupt + }, + { + // 0x3D - MMS Error. + RSat::KMMSError, + RSat::KNoAdditionalInfo, + ETrue, + 0, + KErrCorrupt + }, + { + // 0x3D without additional information (erroneous) + RSat::KMMSError, + RSat::KMeProblem, + ETrue, // Intensional error ! + 0, + KErrCorrupt + } + }; + + const TInt KNumberOfResponsesToTest = sizeof(KResponsesToTest)/ sizeof(KResponsesToTest[0]); + + for(TInt i = 0; i <= KNumberOfResponsesToTest; i++) + { + // Prime Mock with some successfull "SEND SHORT MESSAGE" proactive command + TTpdu tpdu; + MockPrimeSendSmPCmdL(tpdu, ETestSequence11); + + // Invoke RSat::NotifySendSmPCmd() to get the result + TRequestStatus reqStatus; + + RSat::TSendSmV1 sendSm; + RSat::TSendSmV1Pckg sendSmPckg(sendSm); + iSat.NotifySendSmPCmd(reqStatus,sendSmPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + // now test a "TERMINAL RESPONSE" specific to this loop + TInt expectedResult; + + RSat::TSendSmRspV1 rsp; + rsp.SetPCmdNumber(KTestPCmdNumber); + + if(i < KNumberOfResponsesToTest) + { + // looping through KResponsesToTest table + rsp.iGeneralResult = KResponsesToTest[i].iGeneralResult; + rsp.iInfoType = KResponsesToTest[i].iInfoType; + if(rsp.iInfoType != RSat::KNoAdditionalInfo && + !KResponsesToTest[i].iIntentionallyOmmitAdditionalInfo) + { + rsp.iAdditionalInfo.Append(KResponsesToTest[i].iAdditionalInfo); + } + expectedResult = KResponsesToTest[i].iExpectedResult; + // tell Mock to dispatch the forthcoming RSat::TerminalRsp() succesfully + MockPrimeSendSmTerminalResponseL(ETestSequence11,rsp); + } + else + { + // finished with KResponsesToTest table + // now tell Mock to return KErrUnknown when dispatching forthcoming RSat::TerminalRsp() + rsp.iGeneralResult = RSat::KSuccess; + rsp.iInfoType = RSat::KNoAdditionalInfo; + expectedResult = KErrUnknown; + MockPrimeSendSmTerminalResponseL(ETestSequence11,rsp,expectedResult); + } + + // and finally send "TERMINAL RESPONSE" and analyse the result + RSat::TSendSmRspV1Pckg rspPckg(rsp); + iSat.TerminalRsp(reqStatus, RSat::ESendSm, rspPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),expectedResult); + + AssertMockLtsyStatusL(); + } + } + +/** + * Given a testcase primes MOCK with appropriate "SEND SHORT MESSAGE" data + * @param aTpdu created SMS TPDU + * @param aTC testcase identifier + * @param aResultCode result code to be returned by RSat::NotifySendSmPCmd + */ +void CCSatSendSMSFU::MockPrimeSendSmPCmdL(TTpdu& aTpdu, TSendSmTC aTC, TInt aResultCode) + { + // prime Mock with pending "SEND SHORT MESSAGE" request + const TUint8 KPcmdCode = KSendShortMessage; + const TPckgC KPcmdCodePckg(KPcmdCode); + + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,KPcmdCodePckg); + + // trigger "SEND SHORT MESSAGE" event + MockCompleteSendSmPCmdL(aTpdu,aTC,aResultCode); + } + +/** + * Given a testcase primes MOCK with appropriate "TERMINAL RESPONSE" data + * @param aTC testcase identifier + */ +void CCSatSendSMSFU::MockPrimeSendSmTerminalResponseL(TSendSmTC aTC) + { + RSat::TSendSmRspV1 rsp; + FillResponse(rsp,aTC); + MockPrimeSendSmTerminalResponseL(aTC,rsp); + } + +/** + * Given a testcase and filled RSat::TSendSmRspV1 strucuture primes MOCK with appropriate "TERMINAL RESPONSE" data + * @param aTC testcase identifier + * @param aRsp a result to be passed to RSat::TerminalRsp() + * @param aResultCode result code to be returned by RSat::TerminalRsp() + */ +void CCSatSendSMSFU::MockPrimeSendSmTerminalResponseL(TSendSmTC aTC, const RSat::TSendSmRspV1& aRsp, TInt aResultCode) + { + RBuf8 data; + data.CleanupClosePushL(); + + TTlv tlv; + const TUint8 qualifier = CommandQualifier(aTC); + TDesC8* dataPtr = &const_cast(CreateSendSmTerminalResponseTlv(tlv,qualifier,aRsp)); + TMockLtsyData1 termRespData(dataPtr); + termRespData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId, data,aResultCode); + CleanupStack::PopAndDestroy(); + } + +/** + * Triggers "SEND SHORT MESSAGE" event + * @param aTpdu created SMS TPDU + * @param aTC testcase identifier + * @param aResultCode result code to be returned by RSat::NotifySendSmPCmd + */ +void CCSatSendSMSFU::MockCompleteSendSmPCmdL(TTpdu& aTpdu, TSendSmTC aTC, TInt aResultCode) + { + RBuf8 data; + CleanupClosePushL(data); + + CreateSmsTpdu(aTpdu,aTC); + + TTlvBuf tlv; + TDesC8* dataPtr = &const_cast(CreateSendSmTlv(tlv,aTpdu,aTC)); + TMockLtsyData1 tlvPack(dataPtr); + tlvPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,aResultCode,data); + + CleanupStack::PopAndDestroy(); // data + } + +/** + * returns ETrue if command qualifier is set to "packing required" for a given testcase + * @param aTC testcase identifier + * @return ETrue if "packing required" EFalse otherwise + */ +TBool CCSatSendSMSFU::PackingIsUsed(TSendSmTC aTC) + { + TBool result; + switch(aTC) + { + case ETestSequence12: + case ETestSequence14: + case ETestTooBigSmsSubmit8bitPacked: + case ETestTooBigSmsSubmit7bitPacked: + case ETestRelativeVPFPacked: + case ETestEnchancedVPFPacked: + case ETestAbsoluteVPFPacked: + result = ETrue; + break; + + default: + result = EFalse; + } + return result; + } + +/** + * returns expected TPDU for a given testcase + * Should be called only if PackingIsUsed() returns ETrue + * @param aTC testcase identifier + * @return a reference to a descriptor containing expected TPDU + */ +const TDesC8& CCSatSendSMSFU::ExpectedTpdu(TSendSmTC aTC) + { + __ASSERT_ALWAYS(PackingIsUsed(aTC),User::Invariant()); + switch(aTC) + { + case ETestSequence12: + return KSequence12ExpectedTpdu(); + + case ETestRelativeVPFPacked: + return KTestRelativeVPFPackedExpectedTpdu(); + + case ETestEnchancedVPFPacked: + return KTestEnchancedVPFPackedExpectedTpdu(); + + case ETestAbsoluteVPFPacked: + return KTestAbsoluteVPFPackedExpectedTpdu(); + + default: + // ETestSequence14: + return KSequence14ExpectedTpdu(); + + } + } + +/** + * Given a testcase returns corresponding TP-VPF value + * that should be used in the testcase, see clause 9.2.3.3 of the 3GPP TS 23.040 + * @param aTC testcase identifier + * @return TP-VPF value + */ +TUint8 CCSatSendSMSFU::ValidityPeriodFormat(TSendSmTC aTC) + { + TUint8 vpf; + switch(aTC) + { + case ETestRelativeVPF: + case ETestRelativeVPFPacked: + vpf = KSmsVPFRelative; + break; + + case ETestEnchancedVPF: + case ETestEnchancedVPFPacked: + vpf = KSmsVPFEnhanced; + break; + + case ETestAbsoluteVPF: + case ETestAbsoluteVPFPacked: + vpf = KSmsVPFAbsolute; + break; + + default: + vpf = 0; + } + return vpf; + } + +/** + * Given a testcase returns corresponding destination address + * that should be used in the testcase + * @param aTC testcase identifier + * @return a reference to a descriptor containing destination address + */ +const TDesC8& CCSatSendSMSFU::DestinationAddress(TSendSmTC aTC) + { + if(aTC == ETestSequence16) + { + return KShortDestinationAddressString8(); + } + else + { + return KDestinationAddressString8(); + } + } + +/** + * Given a testcase returns corresponding data coding scheme + * that should be used in the testcase + * @param aTC testcase identifier + * @return data coding scheme value + */ +TUint8 CCSatSendSMSFU::DataCodingScheme(TSendSmTC aTC) + { + // Possible TP-DSC (TP-Data-Coding-Scheme) values (see 3GPP TS 23.038 clause 4) + // 0xF0 - Message coding: GSM 7 bit default alphabet + // Message class : Class 0 + + // 0xF1 - Message coding: GSM 7 bit default alphabet + // Message class : Class 1 default meaning: ME-specific. + + // 0xF2 - Message coding: GSM 7 bit default alphabet + // Message class : Class 2 (U)SIM-specific message. + + // 0xF3 - Message coding: GSM 7 bit default alphabet + // Message class : Class 3 default meaning: TE specific + + // 0xF4 - Message coding: 8-bit data + // Message class : Class 0 + + // 0xF5 - Message coding: 8-bit data + // Message class : Class 1 default meaning: ME-specific. + + // 0xF6 - Message coding: 8-bit data + // Message class : Class 2 (U)SIM-specific message. + + // 0xF7 - Message coding: 8-bit data + // Message class : Class 3 default meaning: TE specific + switch(aTC) + { + case ETestSequence13: + case ETestSequence15: + case ETestSequence16: + case ETestTooBigSmsSubmit7bit: + return 0xF0; // GSM 7 bit default alphabet + Class 0 + + default: + return 0xF4; // 8-bit + Class 0 + } + } + +/** + * Given a testcase returns corresponding TP-User-Data-Length value + * that should be used in the testcase + * @param aTC testcase identifier + * @return TP-UDL value + */ +TUint8 CCSatSendSMSFU::UserDataLength(TSendSmTC aTC) + { + switch(aTC) + { + case ETestSequence12: + case ETestRelativeVPFPacked: + case ETestEnchancedVPFPacked: + case ETestAbsoluteVPFPacked: + return KSendSmString8().Length(); + + case ETestSequence13: + return KShortMessageString8().Length(); + + case ETestSequence14: + case ETestSequence15: + return KLongUserDataString8().Length(); + + case ETestSequence16: + return KSingleSpaceUserData8().Length(); + + default: + return KTestMessageString8().Length(); + } + } + +/** + * Given a testcase returns corresponding TP-User-Data value + * that should be used in the testcase + * @param aTC testcase identifier + * @return a reference to a descriptor containing TP-UD + */ +const TDesC8& CCSatSendSMSFU::UserData(TSendSmTC aTC) + { + switch(aTC) + { + case ETestSequence12: + case ETestRelativeVPFPacked: + case ETestEnchancedVPFPacked: + case ETestAbsoluteVPFPacked: + return KSendSmString8(); + + case ETestSequence13: + // return GSM 7 bit encoded string + return KShortMessageStringGSM7(); + + case ETestSequence14: + return KLongUserDataString8(); + + case ETestSequence15: + return KLongUserDataStringGSM7(); + + case ETestSequence16: + return KSingleSpaceUserData8(); + + default: + return KTestMessageString8(); + } + } + +/** + * Given a testcase returns corresponding command qualifier + * that should be used in the testcase + * @param aTC testcase identifier + * @return command qualifier value + */ +TUint8 CCSatSendSMSFU::CommandQualifier(TSendSmTC aTC) + { + // possible "command qualifier" values for "SEND SHORT MESSAGE" are + // 0 = packing not required; + // 1 = SMS packing by the ME required. + return static_cast(PackingIsUsed(aTC)); + } + +/** + * returns ETrue if alpha identifier is used in a given testcase + * @param aTC testcase identifier + * @return ETrue if alpha identifier is used + */ +TBool CCSatSendSMSFU::AlphaIdIsUsed(TSendSmTC aTC) + { + TBool result = ETrue; + if(aTC == ETestSequence18) + { + result = EFalse; + } + return result; + } + +/** + * Given a testcase returns corresponding alpha identifier + * that should be used in the testcase + * @param aTC testcase identifier + * @return a reference to a descriptor containing alpha identifier + */ +const TDesC8& CCSatSendSMSFU::AlphaId(TSendSmTC aTC) + { + switch(aTC) + { + case ETestSequence31A: + case ETestSequence31B: + return KNoIconString8(); + + case ETestSequence13: + return KShortMessageString8(); + + case ETestSequence14: + return KSequence14AlphaString8(); + + case ETestSequence15: + return KSequence15AlphaString8(); + + case ETestSequence16: + return KSequence16AlphaString8(); + + case ETestSequence17: + return KNullDesC8(); + + default: + return KSendSmString8(); + } + } + +/** + * Given a testcase returns an alpha identifier + * that should be returned by RSat API + * @param aTC testcase identifier + * @return a reference to a descriptor containing expected alpha identifier + */ +const TDesC& CCSatSendSMSFU::ExpectedAlphaId(TSendSmTC aTC) + { + switch(aTC) + { + case ETestSequence31A: + case ETestSequence31B: + return KNoIconString16(); + + case ETestSequence13: + return KShortMessageString16(); + + case ETestSequence14: + return KSequence14AlphaString16(); + + case ETestSequence15: + return KSequence15AlphaString16(); + + case ETestSequence16: + return KSequence16AlphaString16(); + + case ETestSequence17: + return KNullDesC(); + + default: + return KSendSmString16(); + } + } + +/** + * Given a testcase returns alpha identifier status + * that should be returned by RSat API + * Should be called only if AlphaIdIsUsed() returns ETrue + * @param aTC testcase identifier + * @return expected alpha identifier status + */ +RSat::TAlphaIdStatus CCSatSendSMSFU::ExpectedAlphaIdStatus(TSendSmTC aTC) + { + __ASSERT_ALWAYS(AlphaIdIsUsed(aTC),User::Invariant()); + RSat::TAlphaIdStatus status = RSat::EAlphaIdProvided; + if(aTC == ETestSequence17) + { + status = RSat::EAlphaIdNull; + } + return status; + } + +/** + * Returns ETrue if address TLV is completely initialized for a given testcase + * @param aTC testcase identifier + * @return ETrue if TLV is completely initialized + */ +TBool CCSatSendSMSFU::CompleteAddressIsUsed(TSendSmTC aTC) + { + TBool result = ETrue; + if(aTC == ETestSequence16 || aTC == ETestMissingAddressType || aTC == ETestMissingDiallingNumber) + { + result = EFalse; + } + return result; + } + +/** + * Given a testcase returns a numbering plan that should be returned by RSat API + * @param aTC testcase identifier + * @return a numbering plan + */ +RSat::TNumberingPlan CCSatSendSMSFU::ExpectedNumberPlan(TSendSmTC aTC) + { + if(CompleteAddressIsUsed(aTC)) + { + // All "SEND SHORT MESSAGE" test sequences listed in 3GPP TS 31.124 + // except 1.6 are using this NPI + return RSat::EIsdnNumberPlan; + } + + if(aTC == ETestSequence16) + { + // Address TLV is omitted in this test + return RSat::ENumberingPlanNotSet; + } + + // aTC is either ETestMissingAddressType or ETestMissingDiallingNumber + return RSat::EUnknownNumberingPlan; + } + +/** + * Given a testcase returns a type of a dialling number that should be returned by RSat API + * @param aTC testcase identifier + * @return expected TON value + */ +RSat::TTypeOfNumber CCSatSendSMSFU::ExpectedTypeOfNumber(TSendSmTC aTC) + { + if(CompleteAddressIsUsed(aTC)) + { + // All "SEND SHORT MESSAGE" test sequences listed in 3GPP TS 31.124 + // except 1.6 are using this TON + return RSat::EInternationalNumber; + } + + if(aTC == ETestSequence16) + { + // Address TLV is omitted in this test + return RSat::ETypeOfNumberNotSet; + } + + // aTC is either ETestMissingAddressType or ETestMissingDiallingNumber + return RSat::EUnknownNumber; + } + +/** + * Returns ETrue if the given testcase is icon-related + * @param aTC testcase identifier + * @return ETrue is the testcase is icon-related + */ +TBool CCSatSendSMSFU::IsIconRelatedTC(TSendSmTC aTC) + { + TBool result = EFalse; + if( aTC == ETestSequence31A || + aTC == ETestSequence31B || + aTC == ETestSequence32A || + aTC == ETestSequence32B ) + { + result = ETrue; + } + return result; + } + +/** + * Given a testcase returns corresponding TLV tag for icon data + * that should be used in the testcase + * @param aTC testcase identifier + * @return TLV tag value + */ +TUint8 CCSatSendSMSFU::IconTlvTag(TSendSmTC aTC) + { + TUint8 tag; + if(aTC == ETestSequence31A || aTC == ETestSequence31B) + { + tag = KTestIconIdentifierTag; + } + else + { + tag = KTlvIconIdentifierTag; + } + return tag; + } + +/** + * Given a testcase returns corresponding icon qualifier + * that should be used in the testcase + * @param aTC testcase identifier + * @return icon qualifier + */ +TUint8 CCSatSendSMSFU::IconQualifier(TSendSmTC aTC) + { + TUint quailfier; + if(aTC == ETestSequence31A || aTC == ETestSequence31B) + { + quailfier = 0; // "self-explanatory" + } + else + { + quailfier = 1; // "not self-explanatory" + } + return quailfier; + } + +/** + * Given a testcase returns an icon qualifier that is expected to be + * returned by RSat API + * @param aTC testcase identifier + * @return expected icon qualifier + */ +RSat::TIconQualifier CCSatSendSMSFU::ExpectedIconQualifier(TSendSmTC aTC) + { + RSat::TIconQualifier quailfier; + if(aTC == ETestSequence31A || aTC == ETestSequence31B) + { + quailfier = RSat::ESelfExplanatory; + } + else + { + quailfier = RSat::ENotSelfExplanatory; + } + return quailfier; + } + +/** + * Given a testcase fills RSat::TSendSmRspV1 appropriately + * @param aTC testcase identifier + * @param aRsp a response to fill + */ +void CCSatSendSMSFU::FillResponse(RSat::TSendSmRspV1& aRsp,TSendSmTC aTC) + { + aRsp.SetPCmdNumber(KTestPCmdNumber); + aRsp.iInfoType = RSat::KNoAdditionalInfo; + + switch(aTC) + { + case ETestSequence31B: + case ETestSequence32B: + aRsp.iGeneralResult = RSat::KSuccessRequestedIconNotDisplayed; + break; + + case ETestTooBigSmsSubmit7bit: + case ETestTooBigSmsSubmit8bit: + case ETestTooBigSmsSubmit7bitPacked: + case ETestTooBigSmsSubmit8bitPacked: + case ETestTooBigSmsCommand: + aRsp.iGeneralResult = RSat::KCmdDataNotUnderstood; + break; + + case ETestMissingSmsTpdu: + aRsp.iGeneralResult = RSat::KErrorRequiredValuesMissing; + break; + + case ETestUnsolictedCompletion: + aRsp.iGeneralResult = RSat::KMeUnableToProcessCmd; + aRsp.iInfoType = RSat::KMeProblem; + aRsp.iAdditionalInfo.Append(0); + break; + + default: + aRsp.iGeneralResult = RSat::KSuccess; + } + } + +/** + * Given a testcase creates appropriate "SMS-SUBMIT" TPDU + * @param aTC testcase identifier + * @param aTpdu a TPDU to create + */ +void CCSatSendSMSFU::CreateSmsSubmitTpdu(TTpdu& aTpdu, TSendSmTC aTC) + { + // See 3GPP TS 23.040 v8.2.0 clause 9.2.2.2 for details + + // TP-MTI (TP-Message-Type-Indicator, first 2 bits) + // Possible values: + // 0x00 (00) SMS-DELIVER (in the direction SC(i.e."Service Center") to MS(i.e."Mobile Station")) + // 0x00 (00) SMS-DELIVER REPORT (in the direction MS to SC) + // 0x02 (10) SMS-STATUS-REPORT (in the direction SC to MS) + // 0x02 (10) SMS-COMMAND (in the direction MS to SC) + // 0x01 (01) SMS-SUBMIT (in the direction MS to SC) + // 0x01 (01) SMS-SUBMIT-REPORT (in the direction SC to MS) + // 0x03 (11) Reserved + TUint8 tpduProtocolByte = 0x01; // SMS-SUBMIT + + // TP-VPF (TP-Validity-Period-Format, 4-th and 5-th bits) + // Parameter indicating whether or not the TP-VP field is present + // Possible values: + // 0x00 (00) TP-VP field not present + // 0x02 (10) TP-VP field present - relative format + // 0x01 (01) TP-VP field present - enhanced format + // 0x03 (11) TP-VP field present - absolute format + const TUint8 KValidityPeriodFormat = ValidityPeriodFormat(aTC); + tpduProtocolByte |= KValidityPeriodFormat; + + aTpdu.Append(tpduProtocolByte); + + // TP-MR (TP-Message-Reference) + aTpdu.Append(0x00); + + // TP-DA (TP-Destination-Address) + const TDesC8& destinationAddress = DestinationAddress(aTC); + //Number of semi-octets + aTpdu.Append(destinationAddress.Length()); + //Type of address + aTpdu.Append(KTestTypeOfAddress); + // Address value + TBuf8> 1> bcdAddress; + TSatUtility::AsciiToBCD(destinationAddress,bcdAddress); + aTpdu.Append(bcdAddress); + + // TP-PID (TP-Protocol-Identifier) + aTpdu.Append(KShortMessageType0); + + // TP-DCS (TP-Data-Coding Scheme) + aTpdu.Append(DataCodingScheme(aTC)); + + // TP-VP (TP-Validity-Period) + // Note: there is no need to set any meaningfull TP-VP values. + // The only thing SAT TSY cares about is TP-VP's length + if(KValidityPeriodFormat == KSmsVPFRelative) + { + // 1-byte TP-VP + aTpdu.Append(KFakeRelativeValidityValue); + } + else if(KValidityPeriodFormat == KSmsVPFAbsolute || + KValidityPeriodFormat == KSmsVPFEnhanced) + { + // 7-bytes TP-VP + aTpdu.Append(KFakeAbsoluteOrEnchancedValidityValue); + } + + // TP-UDL (TP-User-Data-Length) + aTpdu.Append(UserDataLength(aTC)); + + // TP-UD (TP-User-Data) + aTpdu.Append(UserData(aTC)); + } + +/** + * Creates simple "SMS-COMMAND" TPDU + * @param aTpdu a TPDU to create + */ +void CCSatSendSMSFU::CreateSmsCommandTpdu(TTpdu& aTpdu) + { + // See 3GPP TS 23.040 v8.2.0 clause 9.2.2.4 for details + + // set TP-MTI to "SMS-COMMAND", set TP-UDHI and TP-SRR to zero + TUint8 tpduProtocolByte = 0x02; + aTpdu.Append(tpduProtocolByte); + + // TP-MR (TP-Message-Reference) + aTpdu.Append(0x00); + + // TP-PID (TP-Protocol-Identifier) + aTpdu.Append(KShortMessageType0); + + // TP-CT (TP-Command-Type) + aTpdu.Append(0x01); // Cancel Status Report Request relating to previously submitted short message + + // TP-MN (TP-Message-Number) + aTpdu.Append(0x00); + + // TP-DA (TP-Destination-Address) + //Number of semi-octets + aTpdu.Append(KDestinationAddressString8().Length()); + //Type of address + aTpdu.Append(KTestTypeOfAddress); + // Address value + TBuf8> 1> bcdAddress; + TSatUtility::AsciiToBCD(KDestinationAddressString8,bcdAddress); + aTpdu.Append(bcdAddress); + + // TP-CDL (TP-Command-Data-Length) + aTpdu.Append(0x00); + } + +/** + * Given a testcase creates SMS TPDU with too big TP-UDL or TP-CDL value + * @param aTC testcase identifier + * @param aTpdu a TPDU to create + */ +void CCSatSendSMSFU::CreateCorruptedSmsTpdu(TTpdu& aTpdu, TSendSmTC aTC) + { + TUint8 smsType; + if(aTC == ETestTooBigSmsCommand) + { + smsType = 0x02; //SMS-COMMAND + } + else + { + smsType = 0x01; //SMS-SUBMIT + } + aTpdu.Append(smsType); + + // TP-MR (TP-Message-Reference) + aTpdu.Append(0x00); + + if(aTC == ETestTooBigSmsCommand) + { + // TP-PID (TP-Protocol-Identifier) + aTpdu.Append(KShortMessageType0); + + // TP-CT (TP-Command-Type) + aTpdu.Append(0x01); // Cancel Status Report Request relating to previously submitted short message + + // TP-MN (TP-Message-Number) + aTpdu.Append(0x00); + } + + // TP-DA (TP-Destination-Address) + //Number of semi-octets + aTpdu.Append(KDestinationAddressString8().Length()); + //Type of address + aTpdu.Append(KTestTypeOfAddress); + // Address value + TBuf8> 1> bcdAddress; + TSatUtility::AsciiToBCD(KDestinationAddressString8,bcdAddress); + aTpdu.Append(bcdAddress); + + if(aTC != ETestTooBigSmsCommand) + { + // TP-PID (TP-Protocol-Identifier) + aTpdu.Append(KShortMessageType0); + + // TP-DCS (TP-Data-Coding Scheme) + aTpdu.Append(DataCodingScheme(aTC)); + } + + // TP-CDL (TP-Command-Data-Length) / TP-UDL (TP-User-Data-Length) + aTpdu.Append(KSmsMaxSize + 1); + } + +/** + * Given a testcase creates appropriate SMS TPDU + * @param aTC testcase identifier + * @param aTpdu a TPDU to create + */ +void CCSatSendSMSFU::CreateSmsTpdu(TTpdu& aTpdu, TSendSmTC aTC) + { + switch(aTC) + { + case ETestSmsCommand: + CreateSmsCommandTpdu(aTpdu); + break; + + case ETestTooBigSmsSubmit7bit: + case ETestTooBigSmsSubmit8bit: + case ETestTooBigSmsSubmit7bitPacked: + case ETestTooBigSmsSubmit8bitPacked: + case ETestTooBigSmsCommand: + CreateCorruptedSmsTpdu(aTpdu,aTC); + break; + + default: + CreateSmsSubmitTpdu(aTpdu,aTC); + } + } + +/** + * Given a testcase and SMS TPDU creates appropriate "SEND SHORT MESSAGE" TLV data + * @param aTlv a TLV to create + * @param aTpdu SMS TPDU + * @param aTC testcase identifier + */ +const TDesC8& CCSatSendSMSFU::CreateSendSmTlv(TTlvBase& aTlv, const TTpdu& aTpdu, TSendSmTC aTC) + { + aTlv.Begin(KBerTlvProactiveSimCommandTag); + + // ---------------- + // command details + // ---------------- + aTlv.AddTag(KTestCommandDetailsTag); + aTlv.AddByte(KTestPCmdNumber); + aTlv.AddByte(KSendShortMessage); + aTlv.AddByte(CommandQualifier(aTC)); + + // ------------------ + // device identities + // ------------------ + aTlv.AddTag(KTestDeviceIdentityTag); + aTlv.AddByte(KSim); + aTlv.AddByte(KNetwork); + + // --------------------------- + // alpha identifier (optional) + // --------------------------- + if(AlphaIdIsUsed(aTC)) + { + aTlv.AddTag(KTestAlphaIdentifierTag); + aTlv.AddData(AlphaId(aTC)); + } + + // ------------------ + // address (optional) + // ------------------ + if(CompleteAddressIsUsed(aTC)) + { + // add fully initalized address TLV + aTlv.AddTag(KTestAddressTag); + aTlv.AddByte(KTestTypeOfAddress); + + // Dialing number string + TBuf8> 1> dialingNumberString; + TSatUtility::AsciiToBCD(KDialingNumberString8,dialingNumberString); + + aTlv.AddData(dialingNumberString); + } + else + { + if(aTC == ETestMissingAddressType || aTC == ETestMissingDiallingNumber) + { + // add partially initialized address TLV + // first add the tag ... + aTlv.AddTag(KTestAddressTag); + if(aTC == ETestMissingDiallingNumber) + { + // ... now add NPI and TON but not the dialling number + aTlv.AddByte(KTestTypeOfAddress); + } + } + } + + if(aTC != ETestMissingSmsTpdu) + { + // -------- + // SMS TPDU + // -------- + aTlv.AddTag(KTestSmsTpduTag); + aTlv.AddData(aTpdu); + + // --------------- + // Icon identifier + // --------------- + if(IsIconRelatedTC(aTC)) + { + aTlv.AddTag(IconTlvTag(aTC)); + aTlv.AddByte(IconQualifier(aTC)); + aTlv.AddByte(KTestIconIdentifier); + } + } + + const TDesC8& result = aTlv.End(); + + return result; + } + +/** + * Given a testcase and filled RSat::TSendSmRspV1 structure creates appropriate "TERMINAL RESPONSE" TLV + * @param aTlv a TLV to create + * @param aCommandQualifier a command qualifer to be placed to TLV + * @param aRsp terminal response data + */ +const TDesC8& CCSatSendSMSFU::CreateSendSmTerminalResponseTlv(TTlvBase& aTlv, + TUint8 aCommandQualifier, + const RSat::TSendSmRspV1& aRsp) + { + // ---------------- + // command details + // ---------------- + aTlv.AddTag(KTestCommandDetailsTag); + aTlv.AddByte(KTestPCmdNumber); + aTlv.AddByte(KSendShortMessage); + aTlv.AddByte(aCommandQualifier); + + // ------------------ + // device identities + // ------------------ + aTlv.AddTag(KTestDeviceIdentityTag); + aTlv.AddByte(KMe); + aTlv.AddByte(KSim); + + // ------------------ + // result + // ------------------ + aTlv.AddTag(KTestResultTag); + aTlv.AddByte(aRsp.iGeneralResult); + if(aRsp.iInfoType != RSat::KNoAdditionalInfo ) + { + TBuf8 info; + info.Copy(aRsp.iAdditionalInfo); + aTlv.AddData(info); + } + + const TDesC8& result = aTlv.GetDataWithoutTopLevelTag(); + + return result; + } +