diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsysatfunegative.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsysatfunegative.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1970 @@ +// Copyright (c) 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: +// when support for the various APIs are disabled in the dispatch layer. +// + + + +/** + @file The TEFUnit test suite for SmsControl in the Common TSY +*/ + +#include "cctsysatfunegative.h" + +#include +#include +#include +#include + +#include +#include //for KLtsyDispatchPhoneGetPhoneIdApiId +#include //for KLtsyDispatchSmsSendSatSmsApiId +#include //for KLtsyDispatchPhonebookSmsStoreWriteEntryApiId +#include "mockltsyindicatorids.h" +#include "config.h" +#include "testconstants.h" + +const TInt KShiftBitsToGetMSB = 8; + +CTestSuite* CCTsySatFUNegative::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0001L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0002L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0003L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0004L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0005L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0006L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0007L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0008L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0009L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0010L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0011L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0013L); + ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0014L); + + END_SUITE; + } + +CCTsySatFUNegative::~CCTsySatFUNegative() + { + iSat.Close(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0001 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0001L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, EFalse); + + RBuf8 data; + CleanupClosePushL(data); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; + + 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 = enable & 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 = enable & KSmsPpDownloadEnabled; + TMockLtsyData1 smsPpData(smsPpDdlSupported); + data.Close(); + smsPpData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + RSat sat; + TInt ret = sat.Open(iPhone); + ASSERT_EQUALS(ret, KErrNone); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, &data); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0002 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0002L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, EFalse); + + RBuf8 data; + CleanupClosePushL(data); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId); + + TBool smsMoControlActivated = enable & KSmsMoControlEnabled; + TMockLtsyData1 comLtsyData(smsMoControlActivated); + comLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, KErrNone, 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 = enable & 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 = enable & KSmsPpDownloadEnabled; + TMockLtsyData1 smsPpData(smsPpDdlSupported); + data.Close(); + smsPpData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + RSat sat; + TInt ret = sat.Open(iPhone); + ASSERT_EQUALS(ret, KErrNone); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, &data); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0003 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0003L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, EFalse); + + RBuf8 data; + CleanupClosePushL(data); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId); + + TBool smsMoControlActivated = enable & 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(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId); + + TBool ussdSupported = enable & 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 = enable & KSmsPpDownloadEnabled; + TMockLtsyData1 smsPpData(smsPpDdlSupported); + data.Close(); + smsPpData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + RSat sat; + TInt ret = sat.Open(iPhone); + ASSERT_EQUALS(ret, KErrNone); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, &data); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0004 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0004L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, EFalse); + + RBuf8 data; + CleanupClosePushL(data); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId); + + TBool smsMoControlActivated = enable & 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(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId); + iMockLTSY.CompleteL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,KErrNone); + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId); + + TBool smsPpDdlSupported = enable & KSmsPpDownloadEnabled; + TMockLtsyData1 smsPpData(smsPpDdlSupported); + data.Close(); + smsPpData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + RSat sat; + TInt ret = sat.Open(iPhone); + ASSERT_EQUALS(ret, KErrNone); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, &data); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0005 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0005L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId, EFalse); + + RBuf8 data; + CleanupClosePushL(data); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId); + + TBool smsMoControlActivated = enable & 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 = enable & 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(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId); + + TBool smsPpDdlSupported = enable & KSmsPpDownloadEnabled; + TMockLtsyData1 smsPpData(smsPpDdlSupported); + data.Close(); + smsPpData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + RSat sat; + TInt ret = sat.Open(iPhone); + ASSERT_EQUALS(ret, KErrNone); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, &data); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0006 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0006L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, EFalse); + + RBuf8 data; + CleanupClosePushL(data); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId); + + TBool smsMoControlActivated = enable & 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 = enable & 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); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + RSat sat; + TInt ret = sat.Open(iPhone); + ASSERT_EQUALS(ret, KErrNone); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, &data); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0007 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0007L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + TRequestStatus reqStatus; + + const TUint8 KItemIdentifier1 = 77; + 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(),KErrNotSupported); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(this); // data, this + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0008 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0008L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + + TRequestStatus reqStatus; + RSat::TIcon retrievedIconEfImg; + RSat::TIconId iconId; + iconId.iIdentifier = 1; + + iSat.GetIcon(reqStatus,iconId.iIdentifier,retrievedIconEfImg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNotSupported); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(this); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0009 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0009L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId, EFalse); + + 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*******************************************************/ + + //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); + const TUint KIconDataLength = 2; + + 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(),KErrNotSupported); + + AssertMockLtsyStatusL(); + + getData.Close(); + retData.Close(); + + CleanupStack::PopAndDestroy(&retrievedImageinstance); + + CleanupStack::PopAndDestroy(&retData); + CleanupStack::PopAndDestroy(&getData); + CleanupStack::PopAndDestroy(this); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0010 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0010L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId, EFalse); + + 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*************************************/ + + + const TUint KGetClutOffset = 0; //Unused in the CTSY + + // ETel Sat Calls + const TUint KClutLength = 24; + TBuf8 retrievedClut; + iSat.GetClut(reqStatus, KInstanceNumber, KGetClutOffset, retrievedClut); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNotSupported); + + AssertMockLtsyStatusL(); + + getData.Close(); + retData.Close(); + + /*************************************************************************************************/ + + CleanupStack::PopAndDestroy(&retData); + CleanupStack::PopAndDestroy(&getData); + CleanupStack::PopAndDestroy(this); + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0011 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0011L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + const TUint8 KPCommandNumber = 123; + + SetupEventListL(KPCommandNumber,KEventUserActivity); + + //ETel calls event download + RSat::TEventDownloadBaseV2 eventDownload; + RSat::TEventDownloadBaseV2Pckg eventDownloadPck(eventDownload); + RSat::TEventList eventList = RSat::KUserActivity; + + TRequestStatus reqStatus; + iSat.EventDownload(reqStatus, eventList, eventDownloadPck); // No associated data + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(), KErrNotSupported); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(this); + config.Reset(); + } + + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0013 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSmsSendSatSms::KLtsyDispatchSmsSendSatSmsApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0013L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSmsSendSatSms::KLtsyDispatchSmsSendSatSmsApiId, EFalse); + + 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 RSat::TTypeOfNumber KSatTon = RSat::ENetworkSpecificNumber; + const RSat::TNumberingPlan KSatNpi = RSat::EPrivateNumberPlan; + + 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); + + User::WaitForRequest(sendMessageReqStatus); + ASSERT_EQUALS(sendMessageReqStatus.Int(),KErrNotSupported); + + //generate the terminal response to the send sms proactive command. + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + + + config.Reset(); + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0014 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatCallAndSmsControlEnvelope::KLtsyDispatchSatCallAndSmsControlEnvelopeApiId IPC is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsySatFUNegative::TestUnit0014L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchSatCallAndSmsControlEnvelope::KLtsyDispatchSatCallAndSmsControlEnvelopeApiId, EFalse); + + 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(); + + 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); + + config.Reset(); + } + +/** + * Utility function which handles all the Expects/Completes generated by Opening an RSat object. + */ +void CCTsySatFUNegative::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 CCTsySatFUNegative::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 CCTsySatFUNegative::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); + } + + +/** + * Handles sending a terminal response, generating a "command completed successfully" additional info tlv + */ +void CCTsySatFUNegative::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 CCTsySatFUNegative::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 CCTsySatFUNegative::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 CCTsySatFUNegative::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 CCTsySatFUNegative::TonAndNpi(RMobilePhone::TMobileTON aTon, RMobilePhone::TMobileNPI aNpi) + { + return (0x80) | (aTon << 4) | (aNpi); + } + +void CCTsySatFUNegative::DoCleanup() + { + + delete iCallContainer; + iCallContainer = NULL; + + iSat.Close(); + CCtsyComponentTestBase::DoCleanup(); + } + +CCTsySatFUNegative::CCallTypeContainer::CCallTypeContainer() : + iCallControlPckg(iCallControl), + iSetUpCallPckg(iSetUpCall) + { + + } + + +