1 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // when support for the various APIs are disabled in the dispatch layer.

    15 //

    16 

    17 

    18 

    19 /**

    20  @file	The TEFUnit test suite for SmsControl in the Common TSY

    21 */

    22 

    23 #include "cctsysatfunegative.h"

    24 

    25 #include <etelmm.h>

    26 #include <test/tmockltsydata.h>

    27 #include <ctsy/ltsy/sat_defs.h>

    28 #include <cstktsy/ttlv.h>

    29 

    30 #include <ctsy/ltsy/mltsydispatchsatinterface.h>

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

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

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

    34 #include "mockltsyindicatorids.h"

    35 #include "config.h"

    36 #include "testconstants.h"

    37 

    38 const TInt KShiftBitsToGetMSB = 8;

    39 

    40 CTestSuite* CCTsySatFUNegative::CreateSuiteL(const TDesC& aName)

    41 	{

    42 	SUB_SUITE;

    43 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0001L);

    44 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0002L);

    45 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0003L);

    46 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0004L);

    47 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0005L);

    48 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0006L);

    49 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0007L);

    50 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0008L);

    51 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0009L);

    52 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0010L);

    53 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0011L);

    54 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0013L);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsySatFUNegative, TestUnit0014L);

    56 

    57 	END_SUITE;

    58 	}

    59 

    60 CCTsySatFUNegative::~CCTsySatFUNegative()

    61 	{

    62 	iSat.Close();

    63 	}

    64 

    65 /**

    66  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0001

    67  * @SYMComponent telephony_ctsy

    68  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId IPC is disabled 

    69  * @SYMTestPriority High

    70  * @SYMTestActions Disable API, call API, check correct error returned

    71  * @SYMTestExpectedResults Pass

    72  * @SYMTestType CT

    73  */

    74 void CCTsySatFUNegative::TestUnit0001L()

    75 	{

    76 	TConfig config;

    77 	config.SetSupportedValue(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, EFalse);

    78 	

    79 	RBuf8 data;

    80 	CleanupClosePushL(data);

    81 	

    82 	OpenEtelServerL(EUseExtendedError);

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

    84 	OpenPhoneL();

    85 

    86 	TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; 

    87 	

    88 	TUint8 pcmdCode = KPollInterval;

    89 	TMockLtsyData1<TUint8> expLtsyData(pcmdCode);

    90 	data.Close();

    91 	expLtsyData.SerialiseL(data);

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

    93 

    94 	pcmdCode = KPollingOff;

    95 	data.Close();

    96 	expLtsyData.SerialiseL(data);

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

    98 	

    99 	pcmdCode = KMoreTime;

   100 	data.Close();

   101 	expLtsyData.SerialiseL(data);

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

   103 	

   104 	pcmdCode = KTimerManagement;

   105 	data.Close();

   106 	expLtsyData.SerialiseL(data);

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

   108 	

   109 	iMockLTSY.ExpectL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId);

   110 	

   111 	_LIT(KSerialNumber, "12345678");

   112 	

   113 	RMobilePhone::TMobilePhoneIdentityV1 phoneId;

   114 	phoneId.iSerialNumber = KSerialNumber;

   115 	

   116 	TMockLtsyData1<RMobilePhone::TMobilePhoneIdentityV1> phoneIdData(phoneId);

   117 	data.Close();

   118 	phoneIdData.SerialiseL(data);

   119 	iMockLTSY.CompleteL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, KErrNone, data);

   120 	

   121 	iMockLTSY.ExpectL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId);

   122 

   123 	TBuf8<KMaxLengthDefaultBearerData> bearerCapabilities(_L8("TEST BEARER!"));

   124 	TDesC8* bearerCapabilitiesPtr = &bearerCapabilities;

   125 	TMockLtsyData1<TDesC8*> bearerCapabilitiesData(bearerCapabilitiesPtr);

   126 	data.Close();

   127 	bearerCapabilitiesData.SerialiseL(data);

   128 	iMockLTSY.CompleteL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, KErrNone, data);

   129 	

   130 	iMockLTSY.ExpectL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId);

   131 

   132 	TBool ussdSupported = enable & KUssdEnabled;

   133 	TMockLtsyData1<TBool> ussdSupportedData(ussdSupported);

   134 	data.Close();

   135 	ussdSupportedData.SerialiseL(data);

   136 	iMockLTSY.CompleteL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, KErrNone, data);

   137 	iMockLTSY.CompleteL(KMockLtsyDispatchSatUssdControlSupportedChangeIndId, KErrNone, data); //do a future indicator completion as well as this could happen at some point

   138 	

   139 	iMockLTSY.ExpectL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId);

   140 	iMockLTSY.CompleteL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,KErrNone);

   141 	

   142 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId);

   143 

   144 	TBool smsPpDdlSupported = enable & KSmsPpDownloadEnabled;

   145 	TMockLtsyData1<TBool> smsPpData(smsPpDdlSupported);

   146 	data.Close();

   147 	smsPpData.SerialiseL(data);

   148 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data);

   149 

   150 	TRequestStatus reqStatus;

   151 	iMockLTSY.NotifyTerminated(reqStatus); 

   152 

   153 	RSat sat;

   154 	TInt ret = sat.Open(iPhone);

   155 	ASSERT_EQUALS(ret, KErrNone);	

   156 

   157 	User::WaitForRequest(reqStatus);

   158 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   159 		

   160 	AssertMockLtsyStatusL();

   161 	CleanupStack::PopAndDestroy(2, &data);

   162 	config.Reset();

   163 	}

   164 

   165 /**

   166  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0002

   167  * @SYMComponent telephony_ctsy

   168  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId IPC is disabled 

   169  * @SYMTestPriority High

   170  * @SYMTestActions Disable API, call API, check correct error returned

   171  * @SYMTestExpectedResults Pass

   172  * @SYMTestType CT

   173  */

   174 void CCTsySatFUNegative::TestUnit0002L()

   175 	{

   176 	TConfig config;

   177 	config.SetSupportedValue(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, EFalse);

   178 	

   179 	RBuf8 data;

   180 	CleanupClosePushL(data);

   181 	

   182 	OpenEtelServerL(EUseExtendedError);

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

   184 	OpenPhoneL();

   185 	

   186 	TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; 

   187 	

   188 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId);

   189 		

   190 	TBool smsMoControlActivated = enable & KSmsMoControlEnabled;

   191 	TMockLtsyData1<TBool> comLtsyData(smsMoControlActivated);

   192 	comLtsyData.SerialiseL(data);

   193 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, KErrNone, data);

   194 

   195 	iMockLTSY.ExpectL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId);

   196 	

   197 	_LIT(KSerialNumber, "12345678");

   198 	

   199 	RMobilePhone::TMobilePhoneIdentityV1 phoneId;

   200 	phoneId.iSerialNumber = KSerialNumber;

   201 	

   202 	TMockLtsyData1<RMobilePhone::TMobilePhoneIdentityV1> phoneIdData(phoneId);

   203 	data.Close();

   204 	phoneIdData.SerialiseL(data);

   205 	iMockLTSY.CompleteL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, KErrNone, data);

   206 	

   207 	iMockLTSY.ExpectL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId);

   208 

   209 	TBuf8<KMaxLengthDefaultBearerData> bearerCapabilities(_L8("TEST BEARER!"));

   210 	TDesC8* bearerCapabilitiesPtr = &bearerCapabilities;

   211 	TMockLtsyData1<TDesC8*> bearerCapabilitiesData(bearerCapabilitiesPtr);

   212 	data.Close();

   213 	bearerCapabilitiesData.SerialiseL(data);

   214 	iMockLTSY.CompleteL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, KErrNone, data);

   215 	

   216 	iMockLTSY.ExpectL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId);

   217 

   218 	TBool ussdSupported = enable & KUssdEnabled;

   219 	TMockLtsyData1<TBool> ussdSupportedData(ussdSupported);

   220 	data.Close();

   221 	ussdSupportedData.SerialiseL(data);

   222 	iMockLTSY.CompleteL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, KErrNone, data);

   223 	iMockLTSY.CompleteL(KMockLtsyDispatchSatUssdControlSupportedChangeIndId, KErrNone, data); //do a future indicator completion as well as this could happen at some point

   224 	

   225 	iMockLTSY.ExpectL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId);

   226 	iMockLTSY.CompleteL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,KErrNone);

   227 	

   228 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId);

   229 

   230 	TBool smsPpDdlSupported = enable & KSmsPpDownloadEnabled;

   231 	TMockLtsyData1<TBool> smsPpData(smsPpDdlSupported);

   232 	data.Close();

   233 	smsPpData.SerialiseL(data);

   234 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data);

   235 

   236 	TRequestStatus reqStatus;

   237 	iMockLTSY.NotifyTerminated(reqStatus); 

   238 

   239 	RSat sat;

   240 	TInt ret = sat.Open(iPhone);

   241 	ASSERT_EQUALS(ret, KErrNone);	

   242 

   243 	User::WaitForRequest(reqStatus);

   244 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   245 		

   246 	AssertMockLtsyStatusL();

   247 	CleanupStack::PopAndDestroy(2, &data);

   248 	config.Reset();

   249 	}

   250 

   251 /**

   252  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0003

   253  * @SYMComponent telephony_ctsy

   254  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId IPC is disabled 

   255  * @SYMTestPriority High

   256  * @SYMTestActions Disable API, call API, check correct error returned

   257  * @SYMTestExpectedResults Pass

   258  * @SYMTestType CT

   259  */

   260 void CCTsySatFUNegative::TestUnit0003L()

   261 	{

   262 	TConfig config;

   263 	config.SetSupportedValue(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, EFalse);

   264 	

   265 	RBuf8 data;

   266 	CleanupClosePushL(data);

   267 	

   268 	OpenEtelServerL(EUseExtendedError);

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

   270 	OpenPhoneL();

   271 	

   272 	TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; 

   273 	

   274 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId);

   275 		

   276 	TBool smsMoControlActivated = enable & KSmsMoControlEnabled;

   277 	TMockLtsyData1<TBool> comLtsyData(smsMoControlActivated);

   278 	comLtsyData.SerialiseL(data);

   279 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, KErrNone, data);

   280 

   281 	

   282 	TUint8 pcmdCode = KPollInterval;

   283 	TMockLtsyData1<TUint8> expLtsyData(pcmdCode);

   284 	data.Close();

   285 	expLtsyData.SerialiseL(data);

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

   287 

   288 	pcmdCode = KPollingOff;

   289 	data.Close();

   290 	expLtsyData.SerialiseL(data);

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

   292 	

   293 	pcmdCode = KMoreTime;

   294 	data.Close();

   295 	expLtsyData.SerialiseL(data);

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

   297 	

   298 	pcmdCode = KTimerManagement;

   299 	data.Close();

   300 	expLtsyData.SerialiseL(data);

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

   302 	

   303 	iMockLTSY.ExpectL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId);

   304 	

   305 	_LIT(KSerialNumber, "12345678");

   306 	

   307 	RMobilePhone::TMobilePhoneIdentityV1 phoneId;

   308 	phoneId.iSerialNumber = KSerialNumber;

   309 	

   310 	TMockLtsyData1<RMobilePhone::TMobilePhoneIdentityV1> phoneIdData(phoneId);

   311 	data.Close();

   312 	phoneIdData.SerialiseL(data);

   313 	iMockLTSY.CompleteL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, KErrNone, data);

   314 

   315 	iMockLTSY.ExpectL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId);

   316 

   317 	TBool ussdSupported = enable & KUssdEnabled;

   318 	TMockLtsyData1<TBool> ussdSupportedData(ussdSupported);

   319 	data.Close();

   320 	ussdSupportedData.SerialiseL(data);

   321 	iMockLTSY.CompleteL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, KErrNone, data);

   322 	iMockLTSY.CompleteL(KMockLtsyDispatchSatUssdControlSupportedChangeIndId, KErrNone, data); //do a future indicator completion as well as this could happen at some point

   323 	

   324 	iMockLTSY.ExpectL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId);

   325 	iMockLTSY.CompleteL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,KErrNone);

   326 	

   327 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId);

   328 

   329 	TBool smsPpDdlSupported = enable & KSmsPpDownloadEnabled;

   330 	TMockLtsyData1<TBool> smsPpData(smsPpDdlSupported);

   331 	data.Close();

   332 	smsPpData.SerialiseL(data);

   333 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data);

   334 

   335 	TRequestStatus reqStatus;

   336 	iMockLTSY.NotifyTerminated(reqStatus); 

   337 

   338 	RSat sat;

   339 	TInt ret = sat.Open(iPhone);

   340 	ASSERT_EQUALS(ret, KErrNone);	

   341 

   342 	User::WaitForRequest(reqStatus);

   343 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   344 		

   345 	AssertMockLtsyStatusL();

   346 	CleanupStack::PopAndDestroy(2, &data);

   347 	config.Reset();

   348 	}

   349 

   350 /**

   351  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0004

   352  * @SYMComponent telephony_ctsy

   353  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId IPC is disabled 

   354  * @SYMTestPriority High

   355  * @SYMTestActions Disable API, call API, check correct error returned

   356  * @SYMTestExpectedResults Pass

   357  * @SYMTestType CT

   358  */

   359 void CCTsySatFUNegative::TestUnit0004L()

   360 	{

   361 	TConfig config;

   362 	config.SetSupportedValue(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, EFalse);

   363 	

   364 	RBuf8 data;

   365 	CleanupClosePushL(data);

   366 	

   367 	OpenEtelServerL(EUseExtendedError);

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

   369 	OpenPhoneL();

   370 	

   371 	TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; 

   372 	

   373 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId);

   374 		

   375 	TBool smsMoControlActivated = enable & KSmsMoControlEnabled;

   376 	TMockLtsyData1<TBool> comLtsyData(smsMoControlActivated);

   377 	comLtsyData.SerialiseL(data);

   378 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, KErrNone, data);

   379 

   380 	

   381 	TUint8 pcmdCode = KPollInterval;

   382 	TMockLtsyData1<TUint8> expLtsyData(pcmdCode);

   383 	data.Close();

   384 	expLtsyData.SerialiseL(data);

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

   386 

   387 	pcmdCode = KPollingOff;

   388 	data.Close();

   389 	expLtsyData.SerialiseL(data);

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

   391 	

   392 	pcmdCode = KMoreTime;

   393 	data.Close();

   394 	expLtsyData.SerialiseL(data);

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

   396 	

   397 	pcmdCode = KTimerManagement;

   398 	data.Close();

   399 	expLtsyData.SerialiseL(data);

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

   401 	

   402 	iMockLTSY.ExpectL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId);

   403 	

   404 	_LIT(KSerialNumber, "12345678");

   405 	

   406 	RMobilePhone::TMobilePhoneIdentityV1 phoneId;

   407 	phoneId.iSerialNumber = KSerialNumber;

   408 	

   409 	TMockLtsyData1<RMobilePhone::TMobilePhoneIdentityV1> phoneIdData(phoneId);

   410 	data.Close();

   411 	phoneIdData.SerialiseL(data);

   412 	iMockLTSY.CompleteL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, KErrNone, data);

   413 	

   414 	iMockLTSY.ExpectL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId);

   415 

   416 	TBuf8<KMaxLengthDefaultBearerData> bearerCapabilities(_L8("TEST BEARER!"));

   417 	TDesC8* bearerCapabilitiesPtr = &bearerCapabilities;

   418 	TMockLtsyData1<TDesC8*> bearerCapabilitiesData(bearerCapabilitiesPtr);

   419 	data.Close();

   420 	bearerCapabilitiesData.SerialiseL(data);

   421 	iMockLTSY.CompleteL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, KErrNone, data);

   422 	

   423 	iMockLTSY.ExpectL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId);

   424 	iMockLTSY.CompleteL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,KErrNone);

   425 	

   426 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId);

   427 

   428 	TBool smsPpDdlSupported = enable & KSmsPpDownloadEnabled;

   429 	TMockLtsyData1<TBool> smsPpData(smsPpDdlSupported);

   430 	data.Close();

   431 	smsPpData.SerialiseL(data);

   432 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data);

   433 

   434 	TRequestStatus reqStatus;

   435 	iMockLTSY.NotifyTerminated(reqStatus); 

   436 

   437 	RSat sat;

   438 	TInt ret = sat.Open(iPhone);

   439 	ASSERT_EQUALS(ret, KErrNone);	

   440 

   441 	User::WaitForRequest(reqStatus);

   442 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   443 		

   444 	AssertMockLtsyStatusL();

   445 	CleanupStack::PopAndDestroy(2, &data);

   446 	config.Reset();	

   447 	}

   448 

   449 /**

   450  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0005

   451  * @SYMComponent telephony_ctsy

   452  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId IPC is disabled 

   453  * @SYMTestPriority High

   454  * @SYMTestActions Disable API, call API, check correct error returned

   455  * @SYMTestExpectedResults Pass

   456  * @SYMTestType CT

   457  */

   458 void CCTsySatFUNegative::TestUnit0005L()

   459 	{

   460 	TConfig config;

   461 	config.SetSupportedValue(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId, EFalse);

   462 	

   463 	RBuf8 data;

   464 	CleanupClosePushL(data);

   465 	

   466 	OpenEtelServerL(EUseExtendedError);

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

   468 	OpenPhoneL();

   469 	

   470 	TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; 

   471 	

   472 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId);

   473 		

   474 	TBool smsMoControlActivated = enable & KSmsMoControlEnabled;

   475 	TMockLtsyData1<TBool> comLtsyData(smsMoControlActivated);

   476 	comLtsyData.SerialiseL(data);

   477 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, KErrNone, data);

   478 

   479 	

   480 	TUint8 pcmdCode = KPollInterval;

   481 	TMockLtsyData1<TUint8> expLtsyData(pcmdCode);

   482 	data.Close();

   483 	expLtsyData.SerialiseL(data);

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

   485 

   486 	pcmdCode = KPollingOff;

   487 	data.Close();

   488 	expLtsyData.SerialiseL(data);

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

   490 	

   491 	pcmdCode = KMoreTime;

   492 	data.Close();

   493 	expLtsyData.SerialiseL(data);

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

   495 	

   496 	pcmdCode = KTimerManagement;

   497 	data.Close();

   498 	expLtsyData.SerialiseL(data);

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

   500 	

   501 	iMockLTSY.ExpectL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId);

   502 	

   503 	_LIT(KSerialNumber, "12345678");

   504 	

   505 	RMobilePhone::TMobilePhoneIdentityV1 phoneId;

   506 	phoneId.iSerialNumber = KSerialNumber;

   507 	

   508 	TMockLtsyData1<RMobilePhone::TMobilePhoneIdentityV1> phoneIdData(phoneId);

   509 	data.Close();

   510 	phoneIdData.SerialiseL(data);

   511 	iMockLTSY.CompleteL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, KErrNone, data);

   512 	

   513 	iMockLTSY.ExpectL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId);

   514 

   515 	TBuf8<KMaxLengthDefaultBearerData> bearerCapabilities(_L8("TEST BEARER!"));

   516 	TDesC8* bearerCapabilitiesPtr = &bearerCapabilities;

   517 	TMockLtsyData1<TDesC8*> bearerCapabilitiesData(bearerCapabilitiesPtr);

   518 	data.Close();

   519 	bearerCapabilitiesData.SerialiseL(data);

   520 	iMockLTSY.CompleteL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, KErrNone, data);

   521 	

   522 	iMockLTSY.ExpectL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId);

   523 

   524 	TBool ussdSupported = enable & KUssdEnabled;

   525 	TMockLtsyData1<TBool> ussdSupportedData(ussdSupported);

   526 	data.Close();

   527 	ussdSupportedData.SerialiseL(data);

   528 	iMockLTSY.CompleteL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, KErrNone, data);

   529 	iMockLTSY.CompleteL(KMockLtsyDispatchSatUssdControlSupportedChangeIndId, KErrNone, data); //do a future indicator completion as well as this could happen at some point

   530 	

   531 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId);

   532 

   533 	TBool smsPpDdlSupported = enable & KSmsPpDownloadEnabled;

   534 	TMockLtsyData1<TBool> smsPpData(smsPpDdlSupported);

   535 	data.Close();

   536 	smsPpData.SerialiseL(data);

   537 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data);

   538 

   539 	TRequestStatus reqStatus;

   540 	iMockLTSY.NotifyTerminated(reqStatus); 

   541 

   542 	RSat sat;

   543 	TInt ret = sat.Open(iPhone);

   544 	ASSERT_EQUALS(ret, KErrNone);	

   545 

   546 	User::WaitForRequest(reqStatus);

   547 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   548 		

   549 	AssertMockLtsyStatusL();

   550 	CleanupStack::PopAndDestroy(2, &data);

   551 	config.Reset();	

   552 	}

   553 

   554 /**

   555  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0006

   556  * @SYMComponent telephony_ctsy

   557  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId IPC is disabled 

   558  * @SYMTestPriority High

   559  * @SYMTestActions Disable API, call API, check correct error returned

   560  * @SYMTestExpectedResults Pass

   561  * @SYMTestType CT

   562  */

   563 void CCTsySatFUNegative::TestUnit0006L()

   564 	{

   565 	TConfig config;

   566 	config.SetSupportedValue(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, EFalse);

   567 	

   568 	RBuf8 data;

   569 	CleanupClosePushL(data);

   570 	

   571 	OpenEtelServerL(EUseExtendedError);

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

   573 	OpenPhoneL();

   574 	

   575 	TUint8 enable = KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled; 

   576 	

   577 	iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId);

   578 		

   579 	TBool smsMoControlActivated = enable & KSmsMoControlEnabled;

   580 	TMockLtsyData1<TBool> comLtsyData(smsMoControlActivated);

   581 	comLtsyData.SerialiseL(data);

   582 	iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, KErrNone, data);

   583 

   584 	

   585 	TUint8 pcmdCode = KPollInterval;

   586 	TMockLtsyData1<TUint8> expLtsyData(pcmdCode);

   587 	data.Close();

   588 	expLtsyData.SerialiseL(data);

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

   590 

   591 	pcmdCode = KPollingOff;

   592 	data.Close();

   593 	expLtsyData.SerialiseL(data);

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

   595 	

   596 	pcmdCode = KMoreTime;

   597 	data.Close();

   598 	expLtsyData.SerialiseL(data);

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

   600 	

   601 	pcmdCode = KTimerManagement;

   602 	data.Close();

   603 	expLtsyData.SerialiseL(data);

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

   605 	

   606 	iMockLTSY.ExpectL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId);

   607 	

   608 	_LIT(KSerialNumber, "12345678");

   609 	

   610 	RMobilePhone::TMobilePhoneIdentityV1 phoneId;

   611 	phoneId.iSerialNumber = KSerialNumber;

   612 	

   613 	TMockLtsyData1<RMobilePhone::TMobilePhoneIdentityV1> phoneIdData(phoneId);

   614 	data.Close();

   615 	phoneIdData.SerialiseL(data);

   616 	iMockLTSY.CompleteL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, KErrNone, data);

   617 	

   618 	iMockLTSY.ExpectL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId);

   619 

   620 	TBuf8<KMaxLengthDefaultBearerData> bearerCapabilities(_L8("TEST BEARER!"));

   621 	TDesC8* bearerCapabilitiesPtr = &bearerCapabilities;

   622 	TMockLtsyData1<TDesC8*> bearerCapabilitiesData(bearerCapabilitiesPtr);

   623 	data.Close();

   624 	bearerCapabilitiesData.SerialiseL(data);

   625 	iMockLTSY.CompleteL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, KErrNone, data);

   626 	

   627 	iMockLTSY.ExpectL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId);

   628 

   629 	TBool ussdSupported = enable & KUssdEnabled;

   630 	TMockLtsyData1<TBool> ussdSupportedData(ussdSupported);

   631 	data.Close();

   632 	ussdSupportedData.SerialiseL(data);

   633 	iMockLTSY.CompleteL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, KErrNone, data);

   634 	iMockLTSY.CompleteL(KMockLtsyDispatchSatUssdControlSupportedChangeIndId, KErrNone, data); //do a future indicator completion as well as this could happen at some point

   635 	

   636 	iMockLTSY.ExpectL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId);

   637 	iMockLTSY.CompleteL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,KErrNone);

   638 	

   639 	TRequestStatus reqStatus;

   640 	iMockLTSY.NotifyTerminated(reqStatus); 

   641 

   642 	RSat sat;

   643 	TInt ret = sat.Open(iPhone);

   644 	ASSERT_EQUALS(ret, KErrNone);	

   645 

   646 	User::WaitForRequest(reqStatus);

   647 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   648 		

   649 	AssertMockLtsyStatusL();

   650 	CleanupStack::PopAndDestroy(2, &data);

   651 	config.Reset();	

   652 	}

   653 

   654 /**

   655  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0007

   656  * @SYMComponent telephony_ctsy

   657  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId IPC is disabled 

   658  * @SYMTestPriority High

   659  * @SYMTestActions Disable API, call API, check correct error returned

   660  * @SYMTestExpectedResults Pass

   661  * @SYMTestType CT

   662  */

   663 void CCTsySatFUNegative::TestUnit0007L()

   664 	{

   665 	TConfig config;

   666 	config.SetSupportedValue(MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId, EFalse);

   667 	

   668 	OpenEtelServerL(EUseExtendedError);

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

   670 	OpenPhoneL();

   671 	OpenSatL();

   672 		

   673 	TRequestStatus reqStatus;

   674 	

   675 	const TUint8 KItemIdentifier1 = 77;

   676 	RSat::TMenuSelectionV1 menuSelection;

   677 	RSat::TMenuSelectionV1Pckg menuSelectionPckg(menuSelection);

   678 	menuSelection.iItemId = KItemIdentifier1;

   679 	menuSelection.iHelp = RSat::EHelpRequested;

   680 

   681 	iSat.MenuSelection(reqStatus, menuSelectionPckg);

   682 	User::WaitForRequest(reqStatus);

   683 	ASSERT_EQUALS(reqStatus.Int(),KErrNotSupported);

   684 

   685 	AssertMockLtsyStatusL();

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

   687 	config.Reset();

   688 	}

   689 

   690 /**

   691  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0008

   692  * @SYMComponent telephony_ctsy

   693  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId IPC is disabled 

   694  * @SYMTestPriority High

   695  * @SYMTestActions Disable API, call API, check correct error returned

   696  * @SYMTestExpectedResults Pass

   697  * @SYMTestType CT

   698  */

   699 void CCTsySatFUNegative::TestUnit0008L()

   700 	{

   701 	TConfig config;

   702 	config.SetSupportedValue(MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId, EFalse);

   703 

   704 	OpenEtelServerL(EUseExtendedError);

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

   706 	OpenPhoneL();

   707 	OpenSatL();

   708 

   709 	

   710 	TRequestStatus reqStatus;

   711 	RSat::TIcon retrievedIconEfImg;

   712     RSat::TIconId iconId;

   713     iconId.iIdentifier = 1;

   714     

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

   716 	User::WaitForRequest(reqStatus);

   717 	ASSERT_EQUALS(reqStatus.Int(),KErrNotSupported);

   718 	

   719 	AssertMockLtsyStatusL();

   720 	CleanupStack::PopAndDestroy(this);	

   721 	config.Reset();

   722 	}

   723 

   724 /**

   725  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0009

   726  * @SYMComponent telephony_ctsy

   727  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId IPC is disabled 

   728  * @SYMTestPriority High

   729  * @SYMTestActions Disable API, call API, check correct error returned

   730  * @SYMTestExpectedResults Pass

   731  * @SYMTestType CT

   732  */

   733 void CCTsySatFUNegative::TestUnit0009L()

   734 	{

   735 	TConfig config;

   736 	config.SetSupportedValue(MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId, EFalse);

   737 

   738 	OpenEtelServerL(EUseExtendedError);

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

   740 	OpenPhoneL();

   741 	OpenSatL();

   742 	RBuf8 getData;

   743 	CleanupClosePushL(getData);

   744 	

   745 	RBuf8 retData;

   746 	CleanupClosePushL(retData);

   747 	

   748 	TRequestStatus reqStatus;

   749 

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

   751 	

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

   753 	

   754 	//re-create the file path

   755     TBuf8<KFilePathLength> simFilePath(KFilePathLength);

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

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

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

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

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

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

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

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

   764     

   765     //a EF(Img) record to get

   766     const TUint8 KRecordNumber = 5;

   767         

   768     //create the down expect data

   769     TUint8 recordNumber = KRecordNumber;

   770     TDesC8* simFilePathPtr = &simFilePath;

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

   772     getIconData.SerialiseL(getData);

   773 

   774     //create a EF(Img) record    

   775     const TUint KNoImagesLength = 1;

   776     const TUint KEfImgRecordLength = 9;

   777     

   778     RBuf8 iconEfRecordInstance;

   779     CleanupClosePushL(iconEfRecordInstance);

   780     iconEfRecordInstance.CreateMaxL(KEfImgRecordLength);

   781     

   782     const TUint8 KNumberOfImages = 1;

   783     

   784     const TUint16 KInstanceNumber = 1;

   785     const TUint16 KOffset = 1;

   786     const TUint16 KLength = 1;

   787 

   788     const TUint8 KWidth  = 40;

   789     const TUint8 KHeight = 40;

   790     

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

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

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

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

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

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

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

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

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

   800                      

   801     RBuf8 iconEfImgData;

   802     CleanupClosePushL(iconEfImgData);

   803     iconEfImgData.CreateL(KNoImagesLength + KEfImgRecordLength);

   804     iconEfImgData.Append(KNumberOfImages);

   805     iconEfImgData.Append(iconEfRecordInstance);

   806     

   807     

   808     //create the up complete data

   809     TDesC8* iconDataPtr = &iconEfImgData;

   810     TMockLtsyData1<TDesC8*> retIconData(iconDataPtr);

   811     retIconData.SerialiseL(retData);

   812     

   813     //queue the MockLTSY expect completes

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

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

   816 	

   817 	// ETel Sat Calls

   818 	RSat::TIcon retrievedIconEfImg;

   819     RSat::TIconId iconId;

   820     iconId.iIdentifier = KRecordNumber;

   821     

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

   823 	User::WaitForRequest(reqStatus);

   824 	ASSERT_EQUALS(reqStatus.Int(),KErrNone);

   825 	ASSERT_TRUE(iconEfImgData == retrievedIconEfImg);

   826 	

   827 	AssertMockLtsyStatusL();

   828 	

   829 	getData.Close();

   830 	retData.Close();

   831 	

   832 	CleanupStack::PopAndDestroy(&iconEfImgData);

   833 	CleanupStack::PopAndDestroy(&iconEfRecordInstance);

   834 	

   835 	/*************************************************************************************************/

   836 	

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

   838 	

   839 	//this is used in the CTSY to check against the retrieved icon EF(Img) record

   840 	RSat::TInstanceInfoV3 instanceInfo;

   841 	instanceInfo.iInstanceNumber	= KInstanceNumber;

   842 	instanceInfo.iLength			= KLength;

   843 	instanceInfo.iOffset			= KOffset;

   844 	instanceInfo.iCoding			= RSat::KBasic;

   845 	instanceInfo.iImgWidth			= KWidth;

   846 	instanceInfo.iImgHeight			= KHeight;

   847 	instanceInfo.iFileId			= 0; //not used in the CTSY

   848  

   849 	RSat::TInstanceInfoV3Pckg instanceInfoPackage1(instanceInfo);

   850 	const TUint KIconDataLength = 2;

   851 	

   852 	RBuf8 retrievedImageinstance;

   853 	CleanupClosePushL(retrievedImageinstance);

   854 	retrievedImageinstance.CreateL(KIconDataLength + (KWidth * KHeight)); //the EF(IIDF)

   855 	

   856 	// ETel Sat Calls

   857 	iSat.GetImageInstance(reqStatus, instanceInfoPackage1, retrievedImageinstance);

   858 	User::WaitForRequest(reqStatus);

   859 	ASSERT_EQUALS(reqStatus.Int(),KErrNotSupported);

   860 	

   861 	AssertMockLtsyStatusL();

   862 	

   863 	getData.Close();

   864 	retData.Close();

   865 

   866 	CleanupStack::PopAndDestroy(&retrievedImageinstance);

   867 		

   868 	CleanupStack::PopAndDestroy(&retData);

   869 	CleanupStack::PopAndDestroy(&getData);

   870 	CleanupStack::PopAndDestroy(this);		

   871 	config.Reset();

   872 	}

   873 

   874 /**

   875  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0010

   876  * @SYMComponent telephony_ctsy

   877  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId IPC is disabled 

   878  * @SYMTestPriority High

   879  * @SYMTestActions Disable API, call API, check correct error returned

   880  * @SYMTestExpectedResults Pass

   881  * @SYMTestType CT

   882  */

   883 void CCTsySatFUNegative::TestUnit0010L()

   884 	{

   885 	TConfig config;

   886 	config.SetSupportedValue(MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId, EFalse);

   887 	

   888 	OpenEtelServerL(EUseExtendedError);

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

   890 	OpenPhoneL();

   891 	OpenSatL();

   892 	RBuf8 getData;

   893 	CleanupClosePushL(getData);

   894 	

   895 	RBuf8 retData;

   896 	CleanupClosePushL(retData);

   897 	

   898 	TRequestStatus reqStatus;

   899 

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

   901 	

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

   903 	

   904 	//re-create the file path

   905     TBuf8<KFilePathLength> simFilePath(KFilePathLength);

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

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

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

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

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

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

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

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

   914     

   915     //a EF(Img) record to get

   916     const TUint8 KRecordNumber = 5;

   917         

   918     //create the down expect data

   919     TUint8 recordNumber = KRecordNumber;

   920     TDesC8* simFilePathPtr = &simFilePath;

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

   922     getIconData.SerialiseL(getData);

   923 

   924     //create a EF(Img) record    

   925     const TUint KNoImagesLength = 1;

   926     const TUint KEfImgRecordLength = 9;

   927     

   928     RBuf8 iconEfRecordInstance;

   929     CleanupClosePushL(iconEfRecordInstance);

   930     iconEfRecordInstance.CreateMaxL(KEfImgRecordLength);

   931     

   932     const TUint8 KNumberOfImages = 1;

   933     

   934     const TUint16 KInstanceNumber = 1;

   935     const TUint16 KOffset = 1;

   936     const TUint16 KLength = 1;

   937 

   938     const TUint8 KWidth  = 40;

   939     const TUint8 KHeight = 40;

   940     

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

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

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

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

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

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

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

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

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

   950                      

   951     RBuf8 iconEfImgData;

   952     CleanupClosePushL(iconEfImgData);

   953     iconEfImgData.CreateL(KNoImagesLength + KEfImgRecordLength);

   954     iconEfImgData.Append(KNumberOfImages);

   955     iconEfImgData.Append(iconEfRecordInstance);

   956     

   957     

   958     //create the up complete data

   959     TDesC8* iconDataPtr = &iconEfImgData;

   960     TMockLtsyData1<TDesC8*> retIconData(iconDataPtr);

   961     retIconData.SerialiseL(retData);

   962     

   963     //queue the MockLTSY expect completes

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

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

   966 	

   967 	// ETel Sat Calls

   968 	RSat::TIcon retrievedIconEfImg;

   969     RSat::TIconId iconId;

   970     iconId.iIdentifier = KRecordNumber;

   971     

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

   973 	User::WaitForRequest(reqStatus);

   974 	ASSERT_EQUALS(reqStatus.Int(),KErrNone);

   975 	ASSERT_TRUE(iconEfImgData == retrievedIconEfImg);

   976 	

   977 	AssertMockLtsyStatusL();

   978 	

   979 	getData.Close();

   980 	retData.Close();

   981 	

   982 	CleanupStack::PopAndDestroy(&iconEfImgData);

   983 	CleanupStack::PopAndDestroy(&iconEfRecordInstance);

   984 	

   985 	/*************************************************************************************************/

   986 	

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

   988 

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

   990 	

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

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

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

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

   995 	

   996     //create the down expect data

   997 	TUint8 imageInstanceNumberInRecord = KNumberOfImages - KInstanceNumber + 1;

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

   999 	getImageInstanceData.SerialiseL(getData);

  1000 	

  1001     RBuf8 imageInstanceData;

  1002     CleanupClosePushL(imageInstanceData);

  1003     

  1004     RBuf8 imageInstanceBody;

  1005     CleanupClosePushL(imageInstanceBody);

  1006 	

  1007     //A basic image data

  1008     const TUint KIconDataLength = 2;

  1009     imageInstanceData.CreateMaxL(KIconDataLength);

  1010     imageInstanceData[0] = retrievedIconEfImg[KNoImagesLength + 1]; //i.e. KWidth;

  1011     imageInstanceData[1] = retrievedIconEfImg[KNoImagesLength + 2]; //i.e. KHeight;

  1012     

  1013     //The image body

  1014     imageInstanceBody.CreateMaxL(KWidth * KHeight);

  1015     

  1016     //fill with any data (just for testing)

  1017     for(TInt i = 0; i < imageInstanceBody.Length(); ++i)

  1018     	{

  1019     	imageInstanceBody[i] = i;

  1020     	}

  1021     

  1022     TDesC8* imageInstanceDataPtr = &imageInstanceData;

  1023     TDesC8* imageInstanceBodyPtr = &imageInstanceBody;

  1024     

  1025     TMockLtsyData2<TDesC8*,TDesC8*> retImageInstanceData(imageInstanceDataPtr,imageInstanceBodyPtr);

  1026     retImageInstanceData.SerialiseL(retData);

  1027 	

  1028     //queue the MockLTSY expect completes

  1029 	iMockLTSY.ExpectL(MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId,getData);

  1030 	iMockLTSY.CompleteL(MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId, KErrNone, retData);

  1031 	

  1032 	//this is used in the CTSY to check against the retrieved icon EF(Img) record

  1033 	RSat::TInstanceInfoV3 instanceInfo;

  1034 	instanceInfo.iInstanceNumber	= KInstanceNumber;

  1035 	instanceInfo.iLength			= KLength;

  1036 	instanceInfo.iOffset			= KOffset;

  1037 	instanceInfo.iCoding			= RSat::KBasic;

  1038 	instanceInfo.iImgWidth			= KWidth;

  1039 	instanceInfo.iImgHeight			= KHeight;

  1040 	instanceInfo.iFileId			= 0; //not used in the CTSY

  1041  

  1042 	RSat::TInstanceInfoV3Pckg instanceInfoPackage1(instanceInfo);

  1043 	

  1044 	RBuf8 retrievedImageinstance;

  1045 	CleanupClosePushL(retrievedImageinstance);

  1046 	retrievedImageinstance.CreateL(KIconDataLength + (KWidth * KHeight)); //the EF(IIDF)

  1047 	

  1048 	// ETel Sat Calls

  1049 	iSat.GetImageInstance(reqStatus, instanceInfoPackage1, retrievedImageinstance);

  1050 	User::WaitForRequest(reqStatus);

  1051 	ASSERT_EQUALS(reqStatus.Int(),KErrNone);

  1052 	ASSERT_TRUE(retrievedImageinstance.Mid(0,KIconDataLength) == imageInstanceData);

  1053 	ASSERT_TRUE(retrievedImageinstance.Mid(KIconDataLength) == imageInstanceBody);

  1054 	

  1055 	AssertMockLtsyStatusL();

  1056 	

  1057 	getData.Close();

  1058 	retData.Close();

  1059 

  1060 	CleanupStack::PopAndDestroy(&retrievedImageinstance);

  1061 	CleanupStack::PopAndDestroy(&imageInstanceBody);

  1062 	CleanupStack::PopAndDestroy(&imageInstanceData);

  1063 	

  1064 	/*************************************************************************************************/

  1065 

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

  1067 

  1068 

  1069 	const TUint KGetClutOffset = 0; //Unused in the CTSY

  1070 

  1071 	// ETel Sat Calls

  1072 	const TUint KClutLength = 24;

  1073 	TBuf8<KClutLength> retrievedClut;

  1074 	iSat.GetClut(reqStatus, KInstanceNumber, KGetClutOffset, retrievedClut);

  1075 	User::WaitForRequest(reqStatus);

  1076 	ASSERT_EQUALS(reqStatus.Int(),KErrNotSupported);

  1077 

  1078 	AssertMockLtsyStatusL();

  1079 	

  1080 	getData.Close();

  1081 	retData.Close();

  1082 	

  1083 	/*************************************************************************************************/

  1084 		

  1085 	CleanupStack::PopAndDestroy(&retData);

  1086 	CleanupStack::PopAndDestroy(&getData);

  1087 	CleanupStack::PopAndDestroy(this);	

  1088 	config.Reset();

  1089 	}

  1090 

  1091 /**

  1092  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0011

  1093  * @SYMComponent telephony_ctsy

  1094  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId IPC is disabled 

  1095  * @SYMTestPriority High

  1096  * @SYMTestActions Disable API, call API, check correct error returned

  1097  * @SYMTestExpectedResults Pass

  1098  * @SYMTestType CT

  1099  */

  1100 void CCTsySatFUNegative::TestUnit0011L()

  1101 	{

  1102 	TConfig config;

  1103 	config.SetSupportedValue(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId, EFalse);

  1104 	

  1105 	OpenEtelServerL(EUseExtendedError);

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

  1107 	OpenPhoneL();

  1108 	OpenSatL();	

  1109 	

  1110 	const TUint8 KPCommandNumber = 123;

  1111 

  1112 	SetupEventListL(KPCommandNumber,KEventUserActivity);

  1113 	

  1114 	//ETel calls event download

  1115 	RSat::TEventDownloadBaseV2      eventDownload;

  1116 	RSat::TEventDownloadBaseV2Pckg  eventDownloadPck(eventDownload);

  1117 	RSat::TEventList eventList = RSat::KUserActivity;

  1118 

  1119 	TRequestStatus reqStatus;

  1120 	iSat.EventDownload(reqStatus, eventList, eventDownloadPck); // No associated data

  1121 

  1122 	User::WaitForRequest(reqStatus);

  1123 	ASSERT_EQUALS(reqStatus.Int(), KErrNotSupported);

  1124 

  1125 	AssertMockLtsyStatusL();

  1126 	CleanupStack::PopAndDestroy(this);

  1127 	config.Reset();

  1128 	}

  1129 

  1130 

  1131 /**

  1132  * @SYMTestCaseID BA-CTSYD-DIS-SAT-NEGATIVE-UN0013

  1133  * @SYMComponent telephony_ctsy

  1134  * @SYMTestCaseDesc Test handing in CTSY dispatch when the MLtsyDispatchSmsSendSatSms::KLtsyDispatchSmsSendSatSmsApiId IPC is disabled