1 // Copyright (c) 2008-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 //

    15 

    16 

    17 

    18 /**

    19  @file The TEFUnit test suite for SimControl in the Common TSY.

    20 */

    21 

    22 #include "cctsysimfu.h"

    23 #include <etel.h>

    24 #include <etelmm.h>

    25 #include <et_clsvr.h>

    26 #include <ctsy/mmtsy_names.h>

    27 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    28 #include <test/tmockltsydata.h>

    29 #include <ctsy/serviceapi/gsmerror.h>

    30 #include <ctsy/serviceapi/cmmutility.h>

    31 #include <ctsy/ltsy/mltsydispatchsiminterface.h>

    32 #include <ctsy/ltsy/mltsydispatchphoneinterface.h>

    33 #include <etelmmerr.h>

    34 #include <ctsy/ltsy/cctsydispatchercallback.h>

    35 #include <ctsy/ltsy/mltsydispatchsecurityinterface.h>

    36 #include "mockltsyindicatorids.h"

    37 

    38 #include <etelmmerr.h>

    39 #include <e32math.h> 

    40 

    41 CTestSuite* CCTsySimFU::CreateSuiteL(const TDesC& aName)

    42 	{

    43 	SUB_SUITE;

    44 

    45 	//add use-case tests

    46 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUseCase0001L);

    47 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUseCase0002L);

    48 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUseCase0003L);

    49 

    50 	//add other unit tests

    51 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0001L);

    52 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0002L);

    53 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0003L);

    54 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0004L);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0005L);

    56 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0006L);

    57 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0007L);

    58 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0008L);

    59 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0009L);

    60 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0010L);

    61 

    62 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0011L);

    63 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0012L);

    64 	

    65 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0013L);

    66 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0014L);

    67 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0015L);

    68 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0016L);

    69 	ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0017L);

    70 	

    71 	END_SUITE;

    72 	}

    73 

    74 

    75 //

    76 // Use-case tests

    77 //

    78 

    79 /**

    80 @SYMTestCaseID BA-CTSYD-DIS-SIM-UC0001

    81 @SYMComponent telephony_ctsy

    82 @SYMTestCaseDesc Test support in CTSY for get, set and notify for MWIS

    83 @SYMTestPriority High

    84 @SYMTestActions Invokes RMobilePhone::NotifyIccMessageWaitingIndicatorsChange, RMobilePhone::GetIccMessageWaitingIndicators, RMobilePhone::SetIccMessageWaitingIndicators

    85 @SYMTestExpectedResults Pass

    86 @SYMTestType CT

    87  */

    88 void CCTsySimFU::TestUseCase0001L()

    89 	{

    90 	OpenEtelServerL(EUseExtendedError);

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

    92 	OpenPhoneL();

    93 

    94 	RBuf8 data;

    95 	CleanupClosePushL(data);

    96 

    97 	/*

    98 	 * NotifyIccMessageWaitingIndicatorsChange

    99 	 */

   100 

   101 	TRequestStatus requestStatus;

   102 	TRequestStatus mockLtsyStatus;

   103 

   104 	RMobilePhone::TMobilePhoneMessageWaitingV1 mwiRet;

   105 	RMobilePhone::TMobilePhoneMessageWaitingV1Pckg mwiRetPckg(mwiRet);

   106 	iPhone.NotifyIccMessageWaitingIndicatorsChange(requestStatus, mwiRetPckg);

   107 

   108 	// Prepare the NotifyIccMessageWaitingIndicatorsChange data for CompleteL

   109 	RMobilePhone::TMobilePhoneMessageWaitingV1 mwiNotifComplete;

   110 	mwiNotifComplete.iAuxVoiceMsgs = 1;

   111 	mwiNotifComplete.iDataMsgs = 2;

   112 	mwiNotifComplete.iDisplayStatus = 3;

   113 	mwiNotifComplete.iEmailMsgs = 4;

   114 	mwiNotifComplete.iFaxMsgs = 5;

   115 	mwiNotifComplete.iOtherMsgs = 6;

   116 	mwiNotifComplete.iVoiceMsgs = 7;

   117 

   118 	TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1> mockMwisData1(mwiNotifComplete);

   119 

   120 	// Send the CompleteL to MockLtsy

   121 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   122 

   123 	data.Close();

   124 	mockMwisData1.SerialiseL(data);

   125 	iMockLTSY.CompleteL(KMockLtsyDispatchSimNotifyIccMessageWaitingIndicatorsChangeIndId, KErrNone, data);

   126 	User::WaitForRequest(mockLtsyStatus);

   127 	AssertMockLtsyStatusL();

   128     ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   129 

   130     // Check completion of api

   131     User::WaitForRequest(requestStatus);

   132     AssertMockLtsyStatusL();

   133     ASSERT_EQUALS(KErrNone, requestStatus.Int());

   134 

   135     // Check returned data

   136     ASSERT_EQUALS(mwiRet.iAuxVoiceMsgs, mwiNotifComplete.iAuxVoiceMsgs);

   137     ASSERT_EQUALS(mwiRet.iDataMsgs, mwiNotifComplete.iDataMsgs);

   138     ASSERT_EQUALS(mwiRet.iDisplayStatus, mwiNotifComplete.iDisplayStatus);

   139     ASSERT_EQUALS(mwiRet.iEmailMsgs, mwiNotifComplete.iEmailMsgs);

   140     ASSERT_EQUALS(mwiRet.iFaxMsgs, mwiNotifComplete.iFaxMsgs);

   141     ASSERT_EQUALS(mwiRet.iOtherMsgs, mwiNotifComplete.iOtherMsgs);

   142     ASSERT_EQUALS(mwiRet.iVoiceMsgs, mwiNotifComplete.iVoiceMsgs);

   143 

   144 	/*

   145 	 * SetIccMessageWaitingIndicators.

   146 	 * Also test NotifyIccMessageWaitingIndicatorsChange triggered

   147 	 * from a client set when the SetIccMessageWaitingIndicators data values are different to previous values.

   148 	 */

   149 

   150     // Post notification

   151     TRequestStatus requestStatusNotif;

   152     iPhone.NotifyIccMessageWaitingIndicatorsChange(requestStatusNotif, mwiRetPckg);

   153 

   154     // Prepare ExpectL data for the Set

   155 	RMobilePhone::TMobilePhoneMessageWaitingV1 mwiSet;

   156 	RMobilePhone::TMobilePhoneMessageWaitingV1Pckg mwiSetRetPckg(mwiSet);

   157 	// Use values for setting the data that is different to what was used before, so that

   158 	// Ctsy detects a change and hence issues a notification.

   159 	// (Not each of the fields have necessarily to be different).

   160 	mwiSet.iAuxVoiceMsgs = ++mwiNotifComplete.iAuxVoiceMsgs;

   161 	mwiSet.iDataMsgs = ++mwiNotifComplete.iDataMsgs;

   162 	mwiSet.iDisplayStatus = ++mwiNotifComplete.iDisplayStatus;

   163 	mwiSet.iEmailMsgs = ++mwiNotifComplete.iEmailMsgs;

   164 	mwiSet.iFaxMsgs = ++mwiNotifComplete.iFaxMsgs;

   165 	mwiSet.iOtherMsgs = ++mwiNotifComplete.iOtherMsgs;

   166 	mwiSet.iVoiceMsgs = ++mwiNotifComplete.iVoiceMsgs;

   167 

   168 	TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1>setData(mwiSet);

   169 	data.Close();

   170 	setData.SerialiseL(data);

   171 

   172 	iMockLTSY.ExpectL(MLtsyDispatchSimSetIccMessageWaitingIndicators::KLtsyDispatchSimSetIccMessageWaitingIndicatorsApiId, data, KErrNone);

   173 	iMockLTSY.CompleteL(MLtsyDispatchSimSetIccMessageWaitingIndicators::KLtsyDispatchSimSetIccMessageWaitingIndicatorsApiId, KErrNone);

   174 

   175 	// Call api

   176 	TRequestStatus requestStatusSet;

   177 	iPhone.SetIccMessageWaitingIndicators(requestStatusSet, mwiSetRetPckg);

   178 	User::WaitForRequest(requestStatusSet);

   179 	ASSERT_EQUALS(KErrNone, requestStatusSet.Int());

   180 	AssertMockLtsyStatusL();

   181 

   182 	// Wait for notificaion

   183     User::WaitForRequest(requestStatusNotif);

   184     AssertMockLtsyStatusL();

   185     ASSERT_EQUALS(KErrNone, requestStatusNotif.Int());

   186 

   187 	/*

   188 	 * GetIccMessageWaitingIndicators

   189 	 */

   190 

   191 	TRequestStatus requestStatusGet;

   192 

   193 	// Send the ExpectL

   194 	iMockLTSY.ExpectL(MLtsyDispatchSimGetIccMessageWaitingIndicators::KLtsyDispatchSimGetIccMessageWaitingIndicatorsApiId);

   195 

   196 	// Prepare data for the mockLtsy's CompleteL

   197 	RMobilePhone::TMobilePhoneMessageWaitingV1 mwiComp;

   198 	mwiComp.iDisplayStatus = 0xff;

   199 	mwiComp.iVoiceMsgs = 0x01;

   200 	mwiComp.iAuxVoiceMsgs = 0x02;

   201 	mwiComp.iDataMsgs = 0x03;

   202 	mwiComp.iFaxMsgs = 0x04;

   203 	mwiComp.iEmailMsgs = 0x05;

   204 	mwiComp.iOtherMsgs = 0x06;

   205 	TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1> mwisdCompData(mwiComp);

   206 	data.Close();

   207 	mwisdCompData.SerialiseL(data);

   208 	iMockLTSY.CompleteL(MLtsyDispatchSimGetIccMessageWaitingIndicators::KLtsyDispatchSimGetIccMessageWaitingIndicatorsApiId, KErrNone, data);

   209 

   210 	// Now call the ipc

   211 	RMobilePhone::TMobilePhoneMessageWaitingV1 mwiGet;

   212 	RMobilePhone::TMobilePhoneMessageWaitingV1Pckg mwiGetPckg(mwiGet);

   213 	iPhone.GetIccMessageWaitingIndicators(requestStatusGet, mwiGetPckg);

   214 

   215 	User::WaitForRequest(requestStatusGet);

   216 	ASSERT_EQUALS(KErrNone, requestStatusGet.Int());

   217 	AssertMockLtsyStatusL();

   218 

   219 	// Check returned data

   220     ASSERT_EQUALS(mwiGet.iAuxVoiceMsgs, mwiComp.iAuxVoiceMsgs);

   221     ASSERT_EQUALS(mwiGet.iDataMsgs, mwiComp.iDataMsgs);

   222     ASSERT_EQUALS(mwiGet.iDisplayStatus, mwiComp.iDisplayStatus);

   223     ASSERT_EQUALS(mwiGet.iEmailMsgs, mwiComp.iEmailMsgs);

   224     ASSERT_EQUALS(mwiGet.iFaxMsgs, mwiComp.iFaxMsgs);

   225     ASSERT_EQUALS(mwiGet.iOtherMsgs, mwiComp.iOtherMsgs);

   226     ASSERT_EQUALS(mwiGet.iVoiceMsgs, mwiComp.iVoiceMsgs);

   227 

   228     data.Close();

   229 	AssertMockLtsyStatusL();

   230 	CleanupStack::PopAndDestroy(2, this); // data, this

   231 	}

   232 

   233 

   234 /**

   235 @SYMTestCaseID BA-CTSYD-DIS-SIM-UC0002

   236 @SYMComponent telephony_ctsy

   237 @SYMTestCaseDesc Test support in CTSY for APN Control List operations

   238 @SYMTestPriority High

   239 @SYMTestActions Invokes RMobilePhone::GetAPNControlListServiceStatus , RMobilePhone::NotifyAPNControlListServiceStatusChange, RMobilePhone::SetAPNControlListServiceStatus

   240 @SYMTestExpectedResults Pass

   241 @SYMTestType CT

   242  */

   243 void CCTsySimFU::TestUseCase0002L()

   244 	{

   245   OpenEtelServerL(EUseExtendedError);

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

   247 	OpenPhoneL();

   248 

   249 	RBuf8 data;

   250 	CleanupClosePushL(data);

   251 

   252 	TRequestStatus mockLtsyStatus;

   253 

   254 	/*

   255 	 * GetAPNControlListServiceStatus

   256 	 */

   257 

   258 	TRequestStatus requestStatusGet;

   259 

   260 	// Send the ExpectL

   261 	iMockLTSY.ExpectL(MLtsyDispatchSimGetApnControlListServiceStatus::KLtsyDispatchSimGetApnControlListServiceStatusApiId);

   262 

   263 	// Prepare data for the mockLtsy's CompleteL

   264 	RMobilePhone::TAPNControlListServiceStatus statusComp = RMobilePhone::EAPNControlListServiceDisabled;

   265 

   266 	TMockLtsyData1<RMobilePhone::TAPNControlListServiceStatus> statusCompData(statusComp);

   267 	data.Close();

   268 	statusCompData.SerialiseL(data);

   269 	iMockLTSY.CompleteL(MLtsyDispatchSimGetApnControlListServiceStatus::KLtsyDispatchSimGetApnControlListServiceStatusApiId, KErrNone, data);

   270 

   271 	// Now call the ipc

   272 	RMobilePhone::TAPNControlListServiceStatus statusGet;

   273 	iPhone.GetAPNControlListServiceStatus(requestStatusGet, statusGet);

   274 

   275 	User::WaitForRequest(requestStatusGet);

   276 	ASSERT_EQUALS(KErrNone, requestStatusGet.Int());

   277 	AssertMockLtsyStatusL();

   278 	ASSERT_EQUALS(statusGet, statusComp);

   279 

   280 	/*

   281 	 * Set the APN Control List status to Enabled using SetAPNControlListServiceStatus and check for update using

   282 	 * NotifyAPNControlListServiceStatusChange.

   283 	 */

   284 

   285 	// Post notification

   286 	TRequestStatus requestStatusNotif;

   287 	RMobilePhone::TAPNControlListServiceStatus statusNotif;

   288 	iPhone.NotifyAPNControlListServiceStatusChange(requestStatusNotif, statusNotif);

   289 

   290 	// Prepare ExpectL data for the Set

   291 	RMobilePhone::TAPNControlListServiceStatus statusSet = RMobilePhone::EAPNControlListServiceEnabled;

   292 

   293 	TMockLtsyData1<RMobilePhone::TAPNControlListServiceStatus>setData(statusSet);

   294 	data.Close();

   295 	setData.SerialiseL(data);

   296 

   297 	iMockLTSY.ExpectL(MLtsyDispatchSimSetApnControlListServiceStatus::KLtsyDispatchSimSetApnControlListServiceStatusApiId, data, KErrNone);

   298 	iMockLTSY.CompleteL(MLtsyDispatchSimSetApnControlListServiceStatus::KLtsyDispatchSimSetApnControlListServiceStatusApiId, KErrNone);

   299 

   300 	// Call api

   301 	TRequestStatus requestStatusSet;

   302 	iPhone.SetAPNControlListServiceStatus(requestStatusSet, statusSet);

   303 	User::WaitForRequest(requestStatusSet);

   304 	ASSERT_EQUALS(KErrNone, requestStatusSet.Int());

   305 	AssertMockLtsyStatusL();

   306 

   307 	// Prepare CompleteL data for the notification (will be same as that used in the Set).

   308 	RMobilePhone::TAPNControlListServiceStatus statusNotifComp = statusSet;

   309 	TMockLtsyData1<RMobilePhone::TAPNControlListServiceStatus> statusNotifCompData1(statusNotifComp);

   310 	data.Close();

   311 	statusNotifCompData1.SerialiseL(data);

   312 	// Send CompleteL for the notification

   313 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   314 	iMockLTSY.CompleteL(KMockLtsyDispatchSimNotifyApnControlListServiceStatusChangeIndId, KErrNone, data);

   315 	User::WaitForRequest(mockLtsyStatus);

   316 	AssertMockLtsyStatusL();

   317     ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   318 

   319     // Check completion of notification

   320     User::WaitForRequest(requestStatusNotif);

   321     AssertMockLtsyStatusL();

   322     ASSERT_EQUALS(KErrNone, requestStatusNotif.Int());

   323 

   324     // Check data returned in the notification same as date used in the Set.

   325     ASSERT_EQUALS(statusNotif, statusSet);

   326 

   327     data.Close();

   328 	AssertMockLtsyStatusL();

   329 	CleanupStack::PopAndDestroy(2, this); // data, this

   330 	}

   331 

   332 /**

   333 @SYMTestCaseID BA-CTSYD-DIS-SIM-UC0003

   334 @SYMComponent telephony_ctsy

   335 @SYMTestCaseDesc Test support in CTSY for APN list operations

   336 @SYMTestPriority High

   337 @SYMTestActions Invokes RMobilePhone::AppendAPNName, RMobilePhone::DeleteAPNName, RMobilePhone::GetAPNname, RMobilePhone::EnumerateAPNEntries, RMobilePhone::NotifyAPNListChanged

   338 @SYMTestExpectedResults Pass

   339 @SYMTestType CT

   340  */

   341 void CCTsySimFU::TestUseCase0003L()

   342 	{

   343   OpenEtelServerL(EUseExtendedError);

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

   345 	OpenPhoneL();

   346 

   347 	RBuf8 data;

   348 	CleanupClosePushL(data);

   349 

   350 	/*

   351 	 * EnumerateAPNEntries

   352 	 */

   353 

   354 	TRequestStatus requestStatusEnmrt;

   355 

   356 	// Prepare ExpectL and CompleteL data

   357 	iMockLTSY.ExpectL(MLtsyDispatchSimEnumerateApnEntries::KLtsyDispatchSimEnumerateApnEntriesApiId);

   358 

   359 	const TUint32 KNumAPNListEntries = 5;

   360 	TUint32 enmrtComp = KNumAPNListEntries;

   361 	TMockLtsyData1<TUint32> enmrtCompData(enmrtComp);

   362 	data.Close();

   363 	enmrtCompData.SerialiseL(data);

   364 	iMockLTSY.CompleteL(MLtsyDispatchSimEnumerateApnEntries::KLtsyDispatchSimEnumerateApnEntriesApiId, KErrNone, data);

   365 

   366 	// Call ipc

   367 	TUint32 enmrtRet;

   368 	iPhone.EnumerateAPNEntries(requestStatusEnmrt, enmrtRet);

   369 	User::WaitForRequest(requestStatusEnmrt);

   370 	ASSERT_EQUALS(KErrNone, requestStatusEnmrt.Int());

   371 	AssertMockLtsyStatusL();

   372 

   373 	// Check returned data

   374 	ASSERT_EQUALS(enmrtComp, enmrtRet);

   375 

   376 	data.Close();

   377 	AssertMockLtsyStatusL();

   378 

   379 	/*

   380 	 * GetAPNname

   381 	 */

   382 

   383 	TRequestStatus requestStatusGet;

   384 

   385 	// Prepare ExpectL and CompleteL data

   386 	TUint32 index = 69;

   387 	TMockLtsyData1<TUint32> indexData(index);

   388 	indexData.SerialiseL(data);

   389 	iMockLTSY.ExpectL(MLtsyDispatchSimGetApnName::KLtsyDispatchSimGetApnNameApiId, data, KErrNone);

   390 

   391 	RMobilePhone::TAPNEntryV3 apnEntryComp;

   392 	const TBuf8<RMobilePhone::KMaxApnName> KApnName(_L8("Mobile Network access point 1"));

   393 	apnEntryComp.iApn = KApnName;

   394 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> apnEntryData(apnEntryComp);

   395 	data.Close();

   396 	apnEntryData.SerialiseL(data);

   397 	iMockLTSY.CompleteL(MLtsyDispatchSimGetApnName::KLtsyDispatchSimGetApnNameApiId, KErrNone, data);

   398 

   399 	// Call ipc

   400 	RMobilePhone::TAPNEntryV3 apnEntryGet;

   401 	RMobilePhone::TAPNEntryV3Pckg apnEntryGetPckg(apnEntryGet);

   402 	iPhone.GetAPNname(requestStatusGet, index, apnEntryGetPckg);

   403 	User::WaitForRequest(requestStatusGet);

   404 	ASSERT_EQUALS(KErrNone, requestStatusGet.Int());

   405 	AssertMockLtsyStatusL();

   406 

   407 	// Check returned data

   408 	ASSERT_EQUALS(apnEntryGet.iApn, apnEntryComp.iApn);

   409 

   410     data.Close();

   411 	AssertMockLtsyStatusL();

   412 

   413 	/*

   414 	 * DeleteAPNName and notify of change to APN list using NotifyAPNListChanged

   415 	 */

   416 

   417 	// Post notification

   418 	TRequestStatus requestStatusNotif;

   419 	iPhone.NotifyAPNListChanged(requestStatusNotif);

   420 

   421 	// Prepare ExpectL and CompleteL data for the delete

   422 	TUint32 indexDel = 49;

   423 	TMockLtsyData1<TUint32> indexDelData(indexDel);

   424 	indexDelData.SerialiseL(data);

   425 	iMockLTSY.ExpectL(MLtsyDispatchSimDeleteApnName::KLtsyDispatchSimDeleteApnNameApiId, data, KErrNone);

   426 

   427 	iMockLTSY.CompleteL(MLtsyDispatchSimDeleteApnName::KLtsyDispatchSimDeleteApnNameApiId, KErrNone);

   428 

   429 	// Now call the ipc

   430 	TRequestStatus requestStatusDel;

   431 	iPhone.DeleteAPNName(requestStatusDel, indexDel);

   432 	User::WaitForRequest(requestStatusDel);

   433 	ASSERT_EQUALS(KErrNone, requestStatusDel.Int());

   434 	AssertMockLtsyStatusL();

   435 

   436 	// Send CompleteL for noticn

   437 	iMockLTSY.CompleteL(KMockLtsyDispatchSimNotifyApnListChangeIndId , KErrNone);

   438 	User::WaitForRequest(requestStatusNotif);

   439 	ASSERT_EQUALS(KErrNone, requestStatusNotif.Int());

   440 

   441     data.Close();

   442 	AssertMockLtsyStatusL();

   443 

   444 	/*

   445 	 * AppendAPNName

   446 	 */

   447 

   448 	// Prepare ExpectL and CompleteL data for the append

   449 	const TBuf8<RMobilePhone::KMaxApnName> KApnNameAppend(_L8("New Mobile Network access point 2"));

   450 	RMobilePhone::TAPNEntryV3 entryExp;

   451 	entryExp.iApn = KApnNameAppend;

   452 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> entryExpData(entryExp);

   453 	data.Close();

   454 	entryExpData.SerialiseL(data);

   455 	iMockLTSY.ExpectL(MLtsyDispatchSimAppendApnName::KLtsyDispatchSimAppendApnNameApiId, data, KErrNone);

   456 	iMockLTSY.CompleteL(MLtsyDispatchSimAppendApnName::KLtsyDispatchSimAppendApnNameApiId, KErrNone);

   457 

   458 	// Now call the ipc

   459 	TRequestStatus requestStatusApp;

   460 	RMobilePhone::TAPNEntryV3Pckg entryAppPckg(entryExp);

   461 	iPhone.AppendAPNName(requestStatusApp, entryAppPckg);

   462 	User::WaitForRequest(requestStatusApp);

   463 	ASSERT_EQUALS(KErrNone, requestStatusApp.Int());

   464 	AssertMockLtsyStatusL();

   465 

   466     data.Close();

   467 	AssertMockLtsyStatusL();

   468 	CleanupStack::PopAndDestroy(2, this); // data, this

   469 	}

   470 

   471 

   472 

   473 //

   474 // Other unit tests

   475 //

   476 

   477 /**

   478 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0001

   479 @SYMComponent telephony_ctsy

   480 @SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::GetServiceTable

   481 @SYMTestPriority High

   482 @SYMTestActions Invokes RMobilePhone::GetServiceTable

   483 @SYMTestExpectedResults Pass

   484 @SYMTestType UT

   485  */

   486 void CCTsySimFU::TestUnit0001L()

   487 	{

   488 	OpenEtelServerL(EUseExtendedError);

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

   490 	

   491 	RMobilePhone::TMobilePhoneServiceTableV1 simServiceTable;

   492 	simServiceTable.iServices1To8  = 0xFF;

   493 	simServiceTable.iServices9To16 = 0xFF;

   494 	simServiceTable.iServices17To24= 0xFF;

   495 	simServiceTable.iServices25To32= 0xFF;

   496 	simServiceTable.iServices33To40= 0xFF;

   497 	simServiceTable.iServices41To48= 0xFF;

   498 	simServiceTable.iServices49To56= 0xFF;

   499 	

   500 	OpenPhoneL(simServiceTable);

   501 

   502 	TRequestStatus mockLtsyStatus;

   503 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   504 

   505 	RBuf8 data;

   506 	CleanupClosePushL(data);

   507 

   508 	RMobilePhone::TMobilePhoneServiceTableV1 tbData;

   509 	RMobilePhone::TMobilePhoneServiceTableV1Pckg pkg(tbData);

   510 

   511 	//test getting service table when TSY not ready (ICC type is unknown)

   512 	

   513 	TRequestStatus reqStat;

   514 	iPhone.GetServiceTable(reqStat, RMobilePhone::EUSIMServiceTable, pkg);

   515 	User::WaitForRequest(reqStat);

   516 	ASSERT_EQUALS(reqStat.Int(), KErrMMEtelWrongMode);

   517 

   518 	//now get the ICC type.  We do this by invoking NotifySecurityEvent - why I don't know!

   519 	iMockLTSY.ExpectL(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId);

   520 	MLtsyDispatchSimGetActiveIccApplicationType::TIccType type =  MLtsyDispatchSimGetActiveIccApplicationType::EIccTypeSim3G;

   521 	TMockLtsyData1<MLtsyDispatchSimGetActiveIccApplicationType::TIccType> retIccType(type);

   522 	retIccType.SerialiseL(data);

   523 	iMockLTSY.CompleteL(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId,KErrNone,data, 0);

   524 

   525 	iMockLTSY.ExpectL(MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId);

   526 

   527 	RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin1;

   528 	TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> secCodeData(secCode);

   529 	data.Close();

   530 	secCodeData.SerialiseL(data);	

   531 	iMockLTSY.CompleteL(MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId, KErrNone, data);

   532 							

   533 	TRequestStatus reqStat2;

   534 	RMobilePhone::TMobilePhoneSecurityEvent event(RMobilePhone::EUniversalPukVerified);

   535 	iPhone.NotifySecurityEvent(reqStat2, event);

   536 

   537 	User::WaitForRequest(mockLtsyStatus);

   538 	iPhone.CancelAsyncRequest(EMobilePhoneNotifySecurityEvent);

   539 

   540 	User::After(5000000);  // A delay is required by MockSY when being tested on hardware.

   541 

   542 	

   543 	//test getting cached service table

   544 	

   545 	iPhone.GetServiceTable(reqStat, RMobilePhone::ESIMServiceTable, pkg);

   546 	User::WaitForRequest(reqStat);

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

   548 	ASSERT_EQUALS(tbData.iServices1To8,simServiceTable.iServices1To8);

   549 	ASSERT_EQUALS(tbData.iServices9To16,simServiceTable.iServices9To16);

   550 	ASSERT_EQUALS(tbData.iServices17To24,simServiceTable.iServices17To24);

   551 	ASSERT_EQUALS(tbData.iServices25To32,simServiceTable.iServices25To32);

   552 	ASSERT_EQUALS(tbData.iServices33To40,simServiceTable.iServices33To40);

   553 	ASSERT_EQUALS(tbData.iServices41To48,simServiceTable.iServices41To48);

   554 	ASSERT_EQUALS(tbData.iServices49To56,simServiceTable.iServices49To56);

   555 

   556 	//finally test successful retrieval of service table

   557 

   558 	RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::EUSIMServiceTable;

   559 	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTable> serviceTableData(serviceTable);

   560 	data.Close();

   561 	serviceTableData.SerialiseL(data);

   562 	

   563 	iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data);

   564 

   565 	RMobilePhone::TMobilePhoneServiceTableV1 serviceTableResult;

   566 	serviceTableResult.iServices1To8  = 0xFF;

   567 	serviceTableResult.iServices9To16 = 0xFF;

   568 	serviceTableResult.iServices17To24= 0xFF;

   569 	serviceTableResult.iServices25To32= 0xFF;

   570 	serviceTableResult.iServices33To40= 0xFF;

   571 	serviceTableResult.iServices41To48= 0xFF;

   572 	serviceTableResult.iServices49To56= 0xFF;

   573 

   574 	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTableV1> serviceTableResultData(serviceTableResult);

   575 	data.Close();

   576 	serviceTableResultData.SerialiseL(data);

   577 	iMockLTSY.CompleteL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId,KErrNone,data,0);

   578 

   579 	iPhone.GetServiceTable(reqStat, RMobilePhone::EUSIMServiceTable, pkg);

   580 	User::WaitForRequest(reqStat);

   581 	ASSERT_EQUALS(reqStat.Int(), KErrNone);

   582 	ASSERT_EQUALS(tbData.iServices1To8, serviceTableResult.iServices1To8);

   583 	ASSERT_EQUALS(tbData.iServices9To16, serviceTableResult.iServices9To16);

   584 	ASSERT_EQUALS(tbData.iServices17To24, serviceTableResult.iServices17To24);

   585 	ASSERT_EQUALS(tbData.iServices25To32, serviceTableResult.iServices25To32);

   586 	ASSERT_EQUALS(tbData.iServices33To40, serviceTableResult.iServices33To40);

   587 	ASSERT_EQUALS(tbData.iServices41To48, serviceTableResult.iServices41To48);

   588 	ASSERT_EQUALS(tbData.iServices49To56, serviceTableResult.iServices49To56);

   589 

   590 

   591 #ifdef EMULATOR_ONLY

   592 	//test cancel

   593 	

   594 	data.Close();

   595 	serviceTableData.SerialiseL(data);

   596 	iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data);

   597 	//no complete as testing cancel

   598 

   599 	iPhone.GetServiceTable(reqStat, RMobilePhone::EUSIMServiceTable, pkg);

   600 	iPhone.CancelAsyncRequest(EMobilePhoneGetServiceTable);

   601 	User::WaitForRequest(reqStat);

   602 	ASSERT_EQUALS(KErrCancel, reqStat.Int());

   603 #endif // EMULATOR_ONLY

   604 

   605 	data.Close();

   606 	AssertMockLtsyStatusL();

   607 	CleanupStack::PopAndDestroy(2, this); // data, this

   608 	}

   609 

   610 

   611 /**

   612 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0002

   613 @SYMComponent telephony_ctsy

   614 @SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::ChangeSecurityCode

   615 @SYMTestPriority High

   616 @SYMTestActions Invokes RMobilePhone::ChangeSecurityCode

   617 @SYMTestExpectedResults Pass

   618 @SYMTestType UT

   619  */

   620 void CCTsySimFU::TestUnit0002L()

   621 	{

   622 	OpenEtelServerL(EUseExtendedError);

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

   624 	OpenPhoneL();

   625 

   626 	RBuf8 data;

   627 	CleanupClosePushL(data);

   628 

   629 	TRequestStatus reqStatus;

   630 

   631 	_LIT(KOldPwd,"oldPswd");

   632 	_LIT(KNewPwd,"newPswd");

   633 	RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange;

   634 	pwdChange.iNewPassword = KNewPwd;

   635 	pwdChange.iOldPassword = KOldPwd;

   636 

   637 	// Choose Phone Device Lock

   638 	RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;

   639 

   640 	// Prepare Mock Ltsy data for the ExpectL

   641 	TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode,

   642 				   RMobilePhone::TMobilePhonePasswordChangeV1> pwdData(secCode, pwdChange);

   643 	pwdData.SerialiseL(data);

   644 

   645 	iMockLTSY.ExpectL(MLtsyDispatchSimChangeSecurityCode::KLtsyDispatchSimChangeSecurityCodeApiId, data);

   646 

   647 	// The Mock Ltsy CompleteL doesn't require data

   648 	iMockLTSY.CompleteL(MLtsyDispatchSimChangeSecurityCode::KLtsyDispatchSimChangeSecurityCodeApiId, KErrNone);

   649 

   650 	// Call the API

   651 	iPhone.ChangeSecurityCode(reqStatus, secCode, pwdChange);

   652 	User::WaitForRequest(reqStatus);

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

   654 

   655 	data.Close();

   656 

   657 	AssertMockLtsyStatusL();

   658 	CleanupStack::PopAndDestroy(2, this); // data, this

   659 	}

   660 

   661 

   662 /**

   663 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0003

   664 @SYMComponent telephony_ctsy

   665 @SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::GetSubscriberId

   666 @SYMTestPriority High

   667 @SYMTestActions Invokes RMobilePhone::GetSubscriberId

   668 @SYMTestExpectedResults Pass

   669 @SYMTestType UT

   670  */

   671 void CCTsySimFU::TestUnit0003L()

   672 	{

   673 	OpenEtelServerL(EUseExtendedError);

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

   675 	OpenPhoneL();

   676 

   677 	TRequestStatus mockLtsyStatus;

   678 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   679 

   680 	RBuf8 data;

   681 	CleanupClosePushL(data);

   682 

   683 	TRequestStatus reqStatus;

   684 	_LIT8  (KIMSI8, "012012012012999");

   685 	_LIT16(KIMSI16, "012012012012999");

   686 

   687 	// Send the ExpectL

   688 	iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId);

   689 

   690 	// Prepare data for the mockLtsy's CompleteL

   691 	// Note the CTSY expects the data in 8-bit format.

   692 	TBuf8<RMobilePhone::KIMSISize> idComp(KIMSI8);

   693 	TMockLtsyData1<TBuf8<RMobilePhone::KIMSISize> > idCompData(idComp);

   694 

   695 	data.Close();

   696 	idCompData.SerialiseL(data);

   697 	iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data);

   698 

   699 	// Now call the ipc

   700 	RMobilePhone::TMobilePhoneSubscriberId idGet;

   701 	iPhone.GetSubscriberId(reqStatus, idGet);

   702 

   703 	User::WaitForRequest(reqStatus);

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

   705 	AssertMockLtsyStatusL();

   706 	ASSERT_TRUE(idGet == KIMSI16); // ASSERT_EQUALS will not work here

   707 

   708 	data.Close();

   709 	AssertMockLtsyStatusL();

   710 	CleanupStack::PopAndDestroy(2, this); // data, this

   711 	}

   712 

   713 

   714 /**

   715 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0004

   716 @SYMComponent telephony_ctsy

   717 @SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::GetCustomerServiceProfile

   718 @SYMTestPriority High

   719 @SYMTestActions Invokes RMobilePhone::GetCustomerServiceProfile

   720 @SYMTestExpectedResults Pass

   721 @SYMTestType UT

   722  */

   723 void CCTsySimFU::TestUnit0004L()

   724 	{

   725 	OpenEtelServerL(EUseExtendedError);

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

   727 	OpenPhoneL();

   728 

   729 	TRequestStatus mockLtsyStatus;

   730 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   731 

   732 	RBuf8 data;

   733 	CleanupClosePushL(data);

   734 

   735 	TRequestStatus reqStatus;

   736 

   737 	// Send the ExpectL

   738 	iMockLTSY.ExpectL(MLtsyDispatchSimGetCustomerServiceProfile::KLtsyDispatchSimGetCustomerServiceProfileApiId);

   739 

   740 	// Prepare data for the mockLtsy's CompleteL

   741 	RMobilePhone::TMobilePhoneCspFileV1 cspComp;

   742 	cspComp.iCallOfferingServices = 0x01;

   743 	cspComp.iCallRestrictionServices = 0x02;

   744 	cspComp.iOtherSuppServices = 0x03;

   745 	cspComp.iCallCompletionServices = 0x04;

   746 	cspComp.iTeleservices = 0x05;

   747 	cspComp.iCphsTeleservices = 0x06;

   748 	cspComp.iCphsFeatures = 0x07;

   749 	cspComp.iNumberIdentServices = 0x08;

   750 	cspComp.iPhase2PlusServices = 0x09;

   751 	cspComp.iValueAddedServices = 0x0A;

   752 	TMockLtsyData1<RMobilePhone::TMobilePhoneCspFileV1> cspCompData(cspComp);

   753 	data.Close();

   754 	cspCompData.SerialiseL(data);

   755 	iMockLTSY.CompleteL(MLtsyDispatchSimGetCustomerServiceProfile::KLtsyDispatchSimGetCustomerServiceProfileApiId, KErrNone, data);

   756 

   757 	// Now call the ipc

   758 	RMobilePhone::TMobilePhoneCspFileV1 cspGet;

   759 	RMobilePhone::TMobilePhoneCspFileV1Pckg cspGetPckg(cspGet);

   760 	iPhone.GetCustomerServiceProfile(reqStatus, cspGetPckg);

   761 	User::WaitForRequest(reqStatus);

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

   763 	AssertMockLtsyStatusL();

   764 	ASSERT_EQUALS(cspComp.iCallOfferingServices, cspGet.iCallOfferingServices);

   765 	ASSERT_EQUALS(cspComp.iCallRestrictionServices, cspGet.iCallRestrictionServices);

   766 	ASSERT_EQUALS(cspComp.iOtherSuppServices, cspGet.iOtherSuppServices);

   767 	ASSERT_EQUALS(cspComp.iCallCompletionServices, cspGet.iCallCompletionServices);

   768 	ASSERT_EQUALS(cspComp.iTeleservices, cspGet.iTeleservices);

   769 	ASSERT_EQUALS(cspComp.iCphsTeleservices, cspGet.iCphsTeleservices);

   770 	ASSERT_EQUALS(cspComp.iCphsFeatures, cspGet.iCphsFeatures);

   771 	ASSERT_EQUALS(cspComp.iNumberIdentServices, cspGet.iNumberIdentServices);

   772 	ASSERT_EQUALS(cspComp.iPhase2PlusServices, cspGet.iPhase2PlusServices);

   773 	ASSERT_EQUALS(cspComp.iValueAddedServices, cspGet.iValueAddedServices);

   774 

   775 	data.Close();

   776 	AssertMockLtsyStatusL();

   777 	CleanupStack::PopAndDestroy(2, this); // data, this

   778 	}

   779 

   780 

   781 /**

   782 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0005

   783 @SYMComponent telephony_ctsy

   784 @SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::SetFdnSetting, RMobilePhone::VerifySecurityCode

   785 @SYMTestPriority High

   786 @SYMTestActions Invokes RMobilePhone::SetFdnSetting

   787 @SYMTestExpectedResults Pass

   788 @SYMTestType UT

   789  */

   790 void CCTsySimFU::TestUnit0005L()

   791 	{

   792 	/*

   793 	 * This test uses VerifySecurityCode with SetFdnSetting to get the SetFdnSetting sent to the LTSY

   794 	 */

   795 

   796 	OpenEtelServerL(EUseExtendedError);

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

   798 	OpenPhoneL();

   799 

   800 	TRequestStatus mockLtsyStatus;

   801 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   802 

   803 	RBuf8 data;

   804 	CleanupClosePushL(data);

   805 

   806 	TRequestStatus reqStatus, reqStatusNotif, reqStatusVerify;

   807 

   808 	// Prepare data for mockLtsy for the VerifySecurityCode.

   809 	// This mimics the scenario that Pin2 code is required to make SetFdnSetting complete successfully.

   810 	// Therefore we use VerifySecurityCode to supply the Pin2 code.

   811 	RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin2;

   812 

   813 	_LIT(KPwd,"pwd");

   814 	_LIT(KUnblockPwd, "unblockPwd");

   815 	RMobilePhone::TMobilePassword pwd;

   816 	RMobilePhone::TMobilePassword unblockPwd;

   817 	pwd.Copy(KPwd);

   818 	unblockPwd.Copy(KUnblockPwd);

   819 

   820 	RMobilePhone::TCodeAndUnblockCode twoCodes;

   821 	twoCodes.iCode.Copy(KPwd);

   822 	twoCodes.iUnblockCode.Copy(KUnblockPwd);

   823 	TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode, twoCodes);

   824 	verifyData.SerialiseL(data);

   825 

   826 	// Call the ipc for SetFdnSetting.

   827 	// Also call NotifyFdnStatusChange as this is triggered by CTSY when SetFdnSetting completes

   828     RMobilePhone::TMobilePhoneFdnStatus  fdnStatus(RMobilePhone::EFdnUnknown);

   829     iPhone.NotifyFdnStatusChange(reqStatusNotif, fdnStatus);

   830 	RMobilePhone::TMobilePhoneFdnSetting  fdnSetting(RMobilePhone::EFdnSetOff);

   831 	iPhone.SetFdnSetting(reqStatus, fdnSetting);

   832 

   833 	// Send the ExpectL and CompleteL for VerifySecurityCode

   834 	iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data, KErrNone);

   835 	iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrNone);

   836 

   837 	// Send ExpectL for SetFdnSetting

   838 	data.Close();

   839 	TMockLtsyData1<RMobilePhone::TMobilePhoneFdnSetting> setData(fdnSetting);

   840 	data.Close();

   841 	setData.SerialiseL(data);

   842 	iMockLTSY.ExpectL(MLtsyDispatchSimSetFdnSetting::KLtsyDispatchSimSetFdnSettingApiId, data, KErrGeneral);

   843 

   844 	// Call ipc for VerifySecurityCode

   845 	iPhone.VerifySecurityCode(reqStatusVerify, secCode, pwd, unblockPwd);

   846 

   847 	// Wait for VerifySecurityCode...

   848 	User::WaitForRequest(reqStatusVerify);

   849 	ASSERT_EQUALS(KErrNone, reqStatusVerify.Int());

   850 	AssertMockLtsyStatusL();

   851 

   852 	// Now send the CompleteL for SetFdnSetting since CTSY sends this ipc down to LTSY after completing VerifySecurityCode.

   853 	iMockLTSY.CompleteL(MLtsyDispatchSimSetFdnSetting::KLtsyDispatchSimSetFdnSettingApiId, KErrNone);

   854 

   855 	// Wait for SetFdnSetting...

   856 	User::WaitForRequest(reqStatus);

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

   858 	AssertMockLtsyStatusL();

   859 

   860 	User::WaitForRequest(reqStatusNotif);

   861 	ASSERT_EQUALS(KErrNone, reqStatusNotif.Int());

   862 	ASSERT_EQUALS(fdnStatus, RMobilePhone::EFdnNotActive);

   863 

   864 	data.Close();

   865 	AssertMockLtsyStatusL();

   866 	CleanupStack::PopAndDestroy(2, this); // data, this

   867 	}

   868 

   869 /**

   870 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0006

   871 @SYMComponent telephony_ctsy

   872 @SYMTestCaseDesc Test support in CTSYDispatch for a Sim Refresh indicator from teh LTSY

   873 @SYMTestPriority High

   874 @SYMTestActions Invokes SIM Refresh IPC 

   875 @SYMTestExpectedResults Pass

   876 @SYMTestType UT

   877  */

   878 void CCTsySimFU::TestUnit0006L()

   879 	{

   880 	OpenEtelServerL(EUseExtendedError);

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

   882 	

   883 	RBuf8 data;

   884 	CleanupClosePushL(data);

   885 	

   886 	OpenPhoneL();

   887 	

   888 	/****************************Nothing to Refresh***********************************************/

   889 

   890 	//KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline

   891 	TUint16 refreshFileList = 0;

   892 	

   893 	TMockLtsyData1<TUint16> refreshFileListData(refreshFileList);

   894 	refreshFileListData.SerialiseL(data);

   895 	iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data);

   896 	data.Close();

   897 	

   898 	iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId);

   899 	

   900 	// Prepare data for the mockLtsy's CompleteL Note the CTSY expects the data in 8-bit format.

   901 	_LIT8  (KIMSI8, "012012012012999");

   902 	TBuf8<RMobilePhone::KIMSISize> idComp(KIMSI8);

   903 	TMockLtsyData1<TBuf8<RMobilePhone::KIMSISize> > idCompData(idComp);

   904 	idCompData.SerialiseL(data);

   905 	iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data);

   906 	data.Close();

   907 

   908 	WaitForMockLTSYTerminated();

   909 	

   910 	AssertMockLtsyStatusL();

   911 	

   912 	/****************************Service Table Refresh***********************************************/

   913 	

   914 	//KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline

   915 	refreshFileList = KCacheServiceTable;

   916 

   917 	refreshFileListData.SerialiseL(data);

   918 	iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data);

   919 	data.Close();

   920 	

   921 	iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId);

   922 	

   923 	idCompData.SerialiseL(data);

   924 	iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data);

   925 	data.Close();

   926 

   927 	

   928 	RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::ESIMServiceTable;

   929 	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTable> serviceTableData(serviceTable);

   930 	serviceTableData.SerialiseL(data);

   931 	iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data);

   932 	data.Close();

   933 	

   934 	RMobilePhone::TMobilePhoneServiceTableV1 serviceTableResult;

   935 	serviceTableResult.iServices1To8  = 0xFF;

   936 	serviceTableResult.iServices9To16 = 0xFF;

   937 	serviceTableResult.iServices17To24= 0xFF;

   938 	serviceTableResult.iServices25To32= 0xFF;

   939 	serviceTableResult.iServices33To40= 0xFF;

   940 	serviceTableResult.iServices41To48= 0xFF;

   941 	serviceTableResult.iServices49To56= 0xFF;

   942 	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTableV1> serviceTableResultData(serviceTableResult);

   943 	serviceTableResultData.SerialiseL(data);

   944 	iMockLTSY.CompleteL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId,KErrNone,data,0);

   945 	data.Close();

   946 

   947 	

   948 	TInt error = KErrNone;

   949 	TMockLtsyData1<TInt> simRefreshDoneExpLtsyData(error);

   950 	simRefreshDoneExpLtsyData.SerialiseL(data);

   951 	iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data);

   952 	data.Close();

   953 		

   954 	WaitForMockLTSYTerminated();

   955 	

   956 	AssertMockLtsyStatusL();

   957 

   958 	/****************************ALS Line Refresh***********************************************/

   959 

   960 	//KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline

   961 	refreshFileList = KCacheALSline;

   962 

   963 	refreshFileListData.SerialiseL(data);

   964 	iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data);

   965 	data.Close();

   966 	

   967 	iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId);

   968 	

   969 	idCompData.SerialiseL(data);

   970 	iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data);

   971 	data.Close();

   972 	

   973 	error = 0; //CTSY sends down 0 - EFalse, (No Read Error) see CMmPhoneTsy::ResetMEAlsInfo

   974 	simRefreshDoneExpLtsyData.SerialiseL(data);

   975 	iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data);

   976 	data.Close();

   977 		

   978 	WaitForMockLTSYTerminated();

   979 	

   980 	AssertMockLtsyStatusL();

   981 

   982 	/****************************Service Table Refresh && ALS Line Refresh*************************************/

   983 

   984 	//KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline

   985 	refreshFileList = KCacheServiceTable | KCacheALSline;

   986 

   987 	refreshFileListData.SerialiseL(data);

   988 	iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data);

   989 	data.Close();

   990 

   991 	iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId);

   992 	

   993 	idCompData.SerialiseL(data);

   994 	iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data);

   995 	data.Close();

   996 

   997 	serviceTableData.SerialiseL(data);

   998 	iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data);

   999 	data.Close();

  1000 	

  1001 	serviceTableResultData.SerialiseL(data);

  1002 	iMockLTSY.CompleteL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId,KErrNone,data,0);

  1003 	data.Close();

  1004 

  1005 	//CTSY defect would cause teh below expect, now if def'ed out see CMmPhoneTsy::CompleteCacheSimL

  1006 	//error = 1; //CTSY sends down 1

  1007 	//simRefreshDoneExpLtsyData.SerialiseL(data);

  1008 	//iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data);

  1009 	//data.Close();

  1010 

  1011 	error = 0; 

  1012 	simRefreshDoneExpLtsyData.SerialiseL(data);

  1013 	iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data);

  1014 	data.Close();

  1015 

  1016 	

  1017 	WaitForMockLTSYTerminated();

  1018 	

  1019 	AssertMockLtsyStatusL();

  1020 	

  1021 	//see phonebookfu for full refresh of Fdn and Adn phonebooks.

  1022 	

  1023 	CleanupStack::PopAndDestroy(2, this); // data, this

  1024 	}

  1025 

  1026 /**

  1027 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0007

  1028 @SYMComponent telephony_ctsy

  1029 @SYMTestCaseDesc Test support in CTSYDispatch for Power SIM On and Off

  1030 @SYMTestPriority High

  1031 @SYMTestActions Invokes RMmCustomAPI::PowerSimOn() and RMmCustomAPI::PowerSimOff()

  1032 @SYMTestExpectedResults Pass

  1033 @SYMTestType UT

  1034  */

  1035 void CCTsySimFU::TestUnit0007L()

  1036 	{

  1037 	OpenEtelServerL(EUseExtendedError);

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

  1039 	

  1040 	OpenPhoneL();

  1041 	

  1042 	RMmCustomAPI customApi;

  1043 	OpenCustomApiLC(customApi);

  1044 

  1045 	TRequestStatus reqStatus;

  1046 

  1047 	/*******************************************************************/

  1048 	

  1049 	//power sim on with complete returning KErrNone

  1050 	TInt error = KErrNone;

  1051 	

  1052 	iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId);

  1053 	iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId,error);

  1054 	

  1055 	customApi.PowerSimOn(reqStatus);

  1056 	User::WaitForRequest(reqStatus);

  1057 	ASSERT_EQUALS(reqStatus.Int(),error);

  1058 	AssertMockLtsyStatusL();

  1059 

  1060 	/*******************************************************************/

  1061 

  1062 	//power sim on with complete returning KErrGeneral

  1063 	error = KErrGeneral;

  1064 	

  1065 	iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId);

  1066 	iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId,error);

  1067 	

  1068 	customApi.PowerSimOn(reqStatus);

  1069 	User::WaitForRequest(reqStatus);

  1070 	ASSERT_EQUALS(reqStatus.Int(),error);

  1071 	AssertMockLtsyStatusL();

  1072 

  1073 	/*******************************************************************/

  1074 

  1075 	//power sim off with complete returning KErrNone

  1076 	error = KErrNone;

  1077 	

  1078 	iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId);

  1079 	iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId,error);

  1080 	

  1081 	customApi.PowerSimOff(reqStatus);

  1082 	User::WaitForRequest(reqStatus);

  1083 	ASSERT_EQUALS(reqStatus.Int(),error);

  1084 	AssertMockLtsyStatusL();

  1085 

  1086 	/*******************************************************************/

  1087 

  1088 	//power sim off with complete returning KErrGeneral

  1089 	error = KErrGeneral;

  1090 	

  1091 	iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId);

  1092 	iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId,error);

  1093 	

  1094 	customApi.PowerSimOff(reqStatus);

  1095 	User::WaitForRequest(reqStatus);

  1096 	ASSERT_EQUALS(reqStatus.Int(),error);

  1097 	AssertMockLtsyStatusL();

  1098 

  1099 

  1100 	

  1101 	CleanupStack::PopAndDestroy(&customApi);

  1102 	CleanupStack::PopAndDestroy(this);

  1103 	}

  1104 

  1105 /**

  1106 @SYMTestCaseID BA-CTSYD-DIS-SIM-UN0008

  1107 @SYMComponent telephony_ctsy

  1108 @SYMTestCaseDesc Test support in CTSYDispatch for a send APDU request (async and sync)

  1109 @SYMTestPriority High

  1110 @SYMTestActions Invokes RMmCustomAPI::SendAPDUReq()

  1111 @SYMTestExpectedResults Pass

  1112 @SYMTestType UT

  1113  */

  1114 void CCTsySimFU::TestUnit0008L()

  1115 	{

  1116 	OpenEtelServerL(EUseExtendedError);

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

  1118 	

  1119 	RBuf8 data;

  1120 	CleanupClosePushL(data);

  1121 		

  1122 	OpenPhoneL();

  1123 		

  1124 	RMmCustomAPI customApi;

  1125 	OpenCustomApiLC(customApi);

  1126 

  1127 	TRequestStatus reqStatus;

  1128 	

  1129 	_LIT8(KApduDataExp,"APDU DATA EXP ");

  1130 	_LIT8(KApduDataComp,"APDU DATA COMP");

  1131 	TDesC8* commandData = const_cast<TDesC8*>(&KApduDataExp);

  1132 	TDesC8* responseData = const_cast<TDesC8*>(&KApduDataComp);

  1133 	

  1134 	

  1135 	/*****************************************************************************/