1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 /**

    21 @file 

    22 The TEFUnit test suite for CustomIPC in the Common TSY.

    23 */

    24 

    25 #include "cctsycustomipcfu.h"

    26 #include <ctsy/mmtsy_names.h>

    27 #include <etel.h>

    28 #include <etelmm.h>

    29 #include "tmockltsydata.h"

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

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

    32 #include "CMmCustomSecurityTsy.h"

    33 

    34 // constants used by ReadViagHomeZoneCache/WriteViagHomeZoneCache tests

    35 const TInt KViagHomeZoneCacheIdMin = 1;

    36 const TInt KViagHomeZoneCacheIdMax = KPhEngMaxViagHomeZones;

    37 const TInt KViagHomeZoneCacheRecordIdMin = 0;

    38 const TInt KViagHomeZoneCacheRecordIdMax = KPhEngMaxCacheId - 1;

    39 

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

    41 	{

    42 	SUB_SUITE;

    43 

    44 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0001L);

    45 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0002L);

    46 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0004L);

    47 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0005L);		

    48 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0001L);	

    49 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0002L);

    50 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0003L);

    51 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0004L);

    52 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0005L);	

    53 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0001L);

    54 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0002L);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0003L);

    56 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0004L);

    57 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0005L);	

    58 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyDtmfEvent0001L);

    59 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyDtmfEvent0002L);

    60 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyDtmfEvent0004L);	

    61 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetDiagnosticInfo0001L);	

    62 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0001L);

    63 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0002L);

    64 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0004L);	

    65 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0005L);

    66 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0001L);

    67 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0002L);	

    68 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0004L);

    69 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0005L);	

    70 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0001L);

    71 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0002L);

    72 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0004L);

    73 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0005L);	

    74 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetRemoteAlertingToneStatus0001L);	

    75 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCallOrigin0001L);

    76 	

    77 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0001L);

    78 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0002L);

    79 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0003L);

    80 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0004L);

    81 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0005L);

    82 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyAlsBlockedChanged0001L);

    83 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyAlsBlockedChanged0002L);

    84 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyAlsBlockedChanged0004L);

    85 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0001L);

    86 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0002L);

    87 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0004L);

    88 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0005L);

    89 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCipheringInfoChange0001L);

    90 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCipheringInfoChange0002L);

    91 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCipheringInfoChange0004L);

    92 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNSPSStatus0001L);

    93 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNSPSStatus0002L);

    94 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNSPSStatus0004L);

    95 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0001L);

    96 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0002L);

    97 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0004L);

    98 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0005L);

    99 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0001L);

   100 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0002L);

   101 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0003L);

   102 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0004L);

   103 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0005L);

   104 	

   105 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0001L);

   106 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0002L);

   107 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0003L);

   108 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0004L);

   109 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0005L);

   110 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0001L);

   111 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0002L);

   112 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0003L);

   113 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0004L);

   114 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0005L);

   115 	

   116 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0001L);

   117 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0002L);

   118 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0004L);

   119 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0005L);

   120 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsAdditionalInfoNotification0001L);

   121 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsAdditionalInfoNotification0002L);

   122 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsAdditionalInfoNotification0004L);

   123 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsRequestCompleteNotification0001L);

   124 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsRequestCompleteNotification0002L);

   125 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsRequestCompleteNotification0004L);	

   126 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestIsBlocked0001L);

   127 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestIsBlocked0005L);

   128 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0001L);

   129 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0002L);

   130 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0004L);

   131 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0005L);

   132 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetActivePin0001L);

   133 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAirTimeDuration0001L);

   134 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0001L);

   135 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0002L);

   136 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0003L);

   137 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0004L);

   138 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0005L);	

   139 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0001L);

   140 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0002L);

   141 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0004L);

   142 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0005L);

   143 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0001L);

   144 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0001bL);

   145 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0002L);

   146 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0003L);

   147 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0004L);

   148 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetPndCacheStatus0001L);

   149 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetPndCacheStatus0003L);

   150 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0001L);

   151 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0002L);

   152 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0004L);

   153 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0005L);	

   154 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0001L);

   155 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0002L);

   156 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0003L);

   157 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0004L);

   158 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0005L);	

   159 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyProgrammableOperatorLogoChange0001L);

   160 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySsNetworkEvent0001L);

   161 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySsNetworkEvent0002L);

   162 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySsNetworkEvent0004L);	

   163 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCancelUssdSession0001L);	

   164 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSatRefreshCompleteNotification0001L);

   165 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSatRefreshCompleteNotification0002L);

   166 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSatRefreshCompleteNotification0004L);	

   167 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0001L);

   168 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0002L);

   169 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0004L);

   170 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0005L);

   171 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0001L);

   172 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0002L);

   173 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0004L);

   174 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0005L);

   175 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReleaseFile0001L);

   176 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestRestartFile0001L);

   177 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestStartSimCbTopicBrowsing0001L);

   178 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestStartSimCbTopicBrowsing0003L);

   179 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestStartSimCbTopicBrowsing0005L);	

   180 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNextSimCbTopic0001L);

   181 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0001L);

   182 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0002L);

   183 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0003L);

   184 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0004L);

   185 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0005L);

   186 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNetworkConnectionFailure0001L);

   187 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNetworkConnectionFailure0002L);

   188 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNetworkConnectionFailure0004L);

   189 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0001L);

   190 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0002L);

   191 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0003L);

   192 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0004L);

   193 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0005L);	

   194 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0001L);

   195 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0002L);

   196 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0004L);

   197 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0005L);	

   198 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0001L);

   199 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0002L);

   200 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0003L);

   201 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0004L);

   202 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetEGprsInfo0001L);

   203 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetEGprsInfo0003L);	

   204 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0001L);

   205 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0002L);

   206 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0003L);

   207 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0004L);

   208 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0005L);	

   209 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0001L);

   210 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0002L);

   211 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0003L);

   212 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0004L);

   213 

   214 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGet3GPBInfo0001L);	

   215 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0001L);

   216 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0002L);

   217 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0004L);

   218 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0005L);

   219 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0001L);

   220 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0002L);

   221 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0004L);

   222 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0005L);	

   223 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0001L);

   224 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0002L);

   225 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0004L);

   226 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0005L);	

   227 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0001L);

   228 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0002L);

   229 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0004L);

   230 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0005L);	

   231 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0001L);

   232 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0002L);

   233 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0004L);

   234 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0005L);	

   235 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0001L);

   236 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0002L);

   237 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0004L);

   238 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0005L);	

   239 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0001L);	

   240 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0002L);

   241 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0003L);

   242 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0004L);

   243 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0005L);

   244 	

   245 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0001L);

   246 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0002L);

   247 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0004L);

   248 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0005L);	

   249 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySimCardStatus0001L);

   250 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySimCardStatus0002L);

   251 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySimCardStatus0004L);	

   252 	

   253 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0001L); //!!!

   254 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0002L); 

   255 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0003L); 

   256 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0004L); 

   257 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0005L); 

   258 	

   259 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSimMessageStatusRead0001L);

   260 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0001L);

   261 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0002L);

   262 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0004L);

   263 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0005L);	

   264 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0001L);

   265 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0002L);

   266 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0003L);

   267 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0004L);

   268 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyRauEvent0001L);

   269 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyRauEvent0002L);

   270 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyRauEvent0004L);

   271 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0001L);

   272 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0002L);

   273 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0004L);

   274 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0005L);

   275 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0001L);

   276 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0002L);

   277 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0004L);

   278 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0005L);

   279 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyHSxPAStatus0001L);

   280 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyHSxPAStatus0002L);

   281 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyHSxPAStatus0004L);

   282 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0001L);

   283 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0002L);

   284 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0003L);

   285 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0004L);

   286 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0005L);

   287 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0001L);

   288 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0002L);

   289 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0003L);

   290 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0004L);

   291 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0001L);

   292 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0002L);

   293 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0003L);

   294 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0004L);

   295 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0005L);

   296 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0001L);

   297 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0002L);

   298 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0003L);

   299 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0004L);

   300 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0001L);

   301 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0002L);

   302 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0004L);

   303 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0005L);

   304 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0001L);

   305 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0002L);

   306 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0004L);

   307 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0005L);

   308 

   309 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0001L);

   310 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0002L);		

   311 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0003L);		

   312 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0004L);

   313 	ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0005L);

   314 	

   315 	END_SUITE;

   316 	}

   317 

   318 

   319 //////////////////////////////////////////////////////////////////

   320 // Actual test cases

   321 /////////////////////////////////////////////////////////////////

   322 

   323 

   324 /**

   325 @SYMTestCaseID BA-CTSY-CIPC-MCSDM-0001

   326 @SYMComponent  telephony_ctsy

   327 @SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetDriveMode

   328 @SYMTestPriority High

   329 @SYMTestActions Invokes RMmCustomAPI::SetDriveMode

   330 @SYMTestExpectedResults Pass

   331 @SYMTestType CT

   332 */

   333 void CCTsyCustomIPCFU::TestSetDriveMode0001L()

   334 	{

   335 

   336 	OpenEtelServerL(EUseExtendedError);

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

   338 	OpenPhoneL();

   339 

   340 	RBuf8 expectData;

   341 	CleanupClosePushL(expectData);

   342 	

   343 	RMmCustomAPI customAPI;

   344 	OpenCustomAPILC(customAPI, iPhone);

   345 	   

   346 		

   347 	TRequestStatus requestStatus;	

   348 	RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode);    

   349 	

   350  	//-------------------------------------------------------------------------

   351 	// TEST A: failure to dispatch request to LTSY

   352  	//-------------------------------------------------------------------------

   353 	// data for ExpectL

   354 	TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);	

   355     ltsyData.SerialiseL(expectData);	    

   356     iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData, KErrNotSupported);        	

   357     

   358 	customAPI.SetDriveMode(requestStatus, modeStatus);	

   359 	

   360 	User::WaitForRequest(requestStatus);	

   361 	AssertMockLtsyStatusL();

   362 	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

   363 

   364 	//-------------------------------------------------------------------------

   365 	// TEST B: failure on completion of pending request from LTSY->CTSY

   366  	//-------------------------------------------------------------------------	    

   367     iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);   

   368     iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrGeneral);	

   369 	

   370 	customAPI.SetDriveMode(requestStatus, modeStatus);	

   371 	

   372 	User::WaitForRequest(requestStatus);	

   373 	AssertMockLtsyStatusL();

   374 	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

   375 

   376  	//-------------------------------------------------------------------------

   377 	// TEST C: Successful completion request of

   378 	// RMmCustomAPI::SetDriveMode when result is not cached.

   379  	//-------------------------------------------------------------------------

   380 	iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);   

   381     iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone);	

   382 	

   383 	customAPI.SetDriveMode(requestStatus, modeStatus);	

   384 	

   385 	User::WaitForRequest(requestStatus);	

   386 	AssertMockLtsyStatusL();

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

   388 	

   389  	//-------------------------------------------------------------------------

   390 	// TEST E: Unsolicited completion of RMmCustomAPI::SetDriveMode

   391 	// from LTSY.

   392  	//-------------------------------------------------------------------------

   393 	TRequestStatus mockLtsyStatus;

   394 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   395 	iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone);

   396 	User::WaitForRequest(mockLtsyStatus);

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

   398 	

   399 	AssertMockLtsyStatusL();

   400 	

   401 	CleanupStack::PopAndDestroy(3, this); 

   402 	}

   403 

   404 

   405 /**

   406 @SYMTestCaseID BA-CTSY-CIPC-MCSDM-0002

   407 @SYMComponent  telephony_ctsy

   408 @SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SetDriveMode

   409 @SYMTestPriority High

   410 @SYMTestActions Invokes cancelling of RMmCustomAPI::SetDriveMode

   411 @SYMTestExpectedResults Pass

   412 @SYMTestType CT

   413 */

   414 void CCTsyCustomIPCFU::TestSetDriveMode0002L()

   415 	{

   416 

   417 	OpenEtelServerL(EUseExtendedError);

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

   419 	OpenPhoneL();

   420 

   421 	RBuf8 expectData;

   422 	CleanupClosePushL(expectData);

   423 	

   424 	RMmCustomAPI customAPI;

   425 	OpenCustomAPILC(customAPI, iPhone);

   426 		

   427 	TRequestStatus requestStatus;	

   428 	RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode); 

   429 

   430  	//-------------------------------------------------------------------------

   431 	// Test cancelling of RMmCustomAPI::SetDriveMode

   432  	//------------------------------------------------------------------------- 	

   433 

   434 	// data for ExpectL

   435 	TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);	

   436     ltsyData.SerialiseL(expectData);	    

   437     iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData); 

   438     

   439     customAPI.SetDriveMode(requestStatus, modeStatus);

   440 	

   441 	iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone, 20);

   442 	

   443 	customAPI.CancelAsyncRequest(ECustomSetDriveModeIPC);

   444 		

   445 	User::WaitForRequest(requestStatus);		

   446 	// TSY has started a request and it is not possible to then

   447     // cancel it. The best thing for the TSY to do in

   448     // this case is to proceed as though the Cancel never happened.

   449     // The server's call to the TSY cancel function will return

   450     // synchronously. The TSY then continues to wait for the methods

   451     // acknowledgement and when it receives it, the TSY will complete

   452     // the original request.

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

   454 

   455 	AssertMockLtsyStatusL();

   456 	

   457 		

   458 	CleanupStack::PopAndDestroy(3); 

   459 	

   460 	}

   461 

   462 

   463 /**

   464 @SYMTestCaseID BA-CTSY-CIPC-MCSDM-0004

   465 @SYMComponent  telephony_ctsy

   466 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SetDriveMode

   467 @SYMTestPriority High

   468 @SYMTestActions Invokes multiple client requests to RMmCustomAPI::SetDriveMode

   469 @SYMTestExpectedResults Pass

   470 @SYMTestType CT

   471 */

   472 void CCTsyCustomIPCFU::TestSetDriveMode0004L()

   473 	{

   474 					

   475 	OpenEtelServerL(EUseExtendedError);

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

   477 	OpenPhoneL();

   478 

   479 	RBuf8 data;

   480 	CleanupClosePushL(data);

   481 

   482 	// Open second client

   483 	RTelServer telServer2;

   484 	TInt ret = telServer2.Connect();

   485 	ASSERT_EQUALS(KErrNone, ret);

   486 	CleanupClosePushL(telServer2);

   487 

   488 	RMobilePhone phone2;

   489 	ret = phone2.Open(telServer2,KMmTsyPhoneName);

   490 	ASSERT_EQUALS(KErrNone, ret);

   491 	CleanupClosePushL(phone2);

   492 	

   493 	RMmCustomAPI customAPI;

   494 	OpenCustomAPILC(customAPI, iPhone);

   495 	

   496 	RMmCustomAPI customAPI2;

   497 	OpenCustomAPILC(customAPI2, phone2, EFalse);

   498 			

   499 	RBuf8 expectData;

   500 	CleanupClosePushL(expectData);

   501 	

   502 	RBuf8 expectData2;

   503 	CleanupClosePushL(expectData2);	

   504 	

   505 	TRequestStatus requestStatus;	

   506 	RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode); 

   507 	

   508 	TRequestStatus requestStatus2;	

   509 	RMmCustomAPI::TSetDriveMode modeStatus2(RMmCustomAPI::EDeactivateDriveMode); 

   510 	

   511 

   512 	//-------------------------------------------------------------------------

   513 	// Test A: Test multiple clients requesting RMmCustomAPI::SetDriveMode

   514  	//-------------------------------------------------------------------------

   515  	

   516  	// data for the first ExpectL

   517 	TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);	

   518     ltsyData.SerialiseL(expectData);	    

   519        

   520     // data for the second ExpectL

   521 	TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData2(modeStatus2);	

   522     ltsyData2.SerialiseL(expectData2);	    

   523         

   524     // first SetDriveMode

   525     iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);

   526     iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone, 20);

   527     

   528     customAPI.SetDriveMode(requestStatus, modeStatus);

   529                 

   530     

   531     

   532     customAPI2.SetDriveMode(requestStatus2, modeStatus2); 	

   533  	

   534  	

   535  	// wait for the first answer

   536  	User::WaitForRequest(requestStatus);		

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

   538 	

   539 	// wait for the second answer

   540  	User::WaitForRequest(requestStatus2);

   541  	// Documentation says that KErrServerBusy should be in case of multiple requests

   542 	ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());	

   543 	

   544 	AssertMockLtsyStatusL();

   545 

   546 	CleanupStack::PopAndDestroy(8, this); 

   547 

   548 	}

   549 

   550 

   551 /**

   552 @SYMTestCaseID BA-CTSY-CIPC-MCSDM-0005

   553 @SYMComponent  telephony_ctsy

   554 @SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetDriveMode with timeout

   555 @SYMTestPriority High

   556 @SYMTestActions Invokes RMmCustomAPI::SetDriveMode and tests for timeout

   557 @SYMTestExpectedResults Pass

   558 @SYMTestType CT

   559 */

   560 void CCTsyCustomIPCFU::TestSetDriveMode0005L()

   561 	{

   562 

   563 	OpenEtelServerL(EUseExtendedError);

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

   565 	OpenPhoneL();

   566 

   567 	RBuf8 expectData;

   568 	CleanupClosePushL(expectData);

   569 	

   570 	RMmCustomAPI customAPI;

   571 	OpenCustomAPILC(customAPI, iPhone);

   572 	

   573 	

   574 	TRequestStatus requestStatus;	

   575 	RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode); 

   576 

   577 	//-------------------------------------------------------------------------

   578 	// Test A: Test timeout of RMmCustomAPI::SetDriveMode

   579  	//-------------------------------------------------------------------------

   580 

   581 	// data for ExpectL

   582 	TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);	

   583     ltsyData.SerialiseL(expectData);	    

   584     iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData); 

   585     

   586     customAPI.SetDriveMode(requestStatus, modeStatus);

   587 		

   588 	User::WaitForRequest(requestStatus);	

   589 	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());

   590 

   591 	AssertMockLtsyStatusL();

   592 

   593 	CleanupStack::PopAndDestroy(3, this); 

   594 

   595 	}

   596 

   597 

   598 /**

   599 @SYMTestCaseID BA-CTSY-CIPC-MCASL-0001

   600 @SYMComponent  telephony_ctsy

   601 @SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ActivateSimLock

   602 @SYMTestPriority High

   603 @SYMTestActions Invokes RMmCustomAPI::ActivateSimLock

   604 @SYMTestExpectedResults Pass

   605 @SYMTestType CT

   606 */

   607 void CCTsyCustomIPCFU::TestActivateSimLock0001L()

   608 	{

   609 

   610 	OpenEtelServerL(EUseExtendedError);

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

   612 	OpenPhoneL();

   613 

   614 	RBuf8 expectData;

   615 	CleanupClosePushL(expectData);

   616 	

   617 	RMmCustomAPI customAPI;

   618 	OpenCustomAPILC(customAPI, iPhone);

   619 	

   620 	

   621 	TRequestStatus requestStatus;	

   622 	 

   623  	//-------------------------------------------------------------------------

   624 	// TEST A: failure to dispatch request to LTSY

   625  	//-------------------------------------------------------------------------

   626 	RMmCustomAPI::TSimLockPassword password(_L("changeme"));

   627 	RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator);	

   628 	

   629 	// data for ExpectL

   630 	TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > 

   631 									ltsyData(password, lockNumber);	    

   632     ltsyData.SerialiseL(expectData);    	    

   633     iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData, KErrNotSupported);

   634     

   635 	customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   636 	

   637 	User::WaitForRequest(requestStatus);	

   638 	

   639 	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

   640 	AssertMockLtsyStatusL();

   641 

   642 	//-------------------------------------------------------------------------

   643 	// TEST B: failure on completion of pending request from LTSY->CTSY

   644  	//-------------------------------------------------------------------------	

   645 

   646 	// use othere number for coverage increasing

   647 	lockNumber = RMmCustomAPI::EGid1;

   648 	

   649 	// data for ExpectL

   650 	expectData.Close();

   651     ltsyData.SerialiseL(expectData);    	    

   652     iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);

   653     iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrGeneral);

   654 	

   655 	customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   656 	

   657 	User::WaitForRequest(requestStatus);	

   658 	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

   659 	AssertMockLtsyStatusL();

   660 

   661  	//-------------------------------------------------------------------------

   662 	// TEST C: Successful completion request of

   663 	// RMmCustomAPI::ActivateSimLock when result is not cached.

   664  	//-------------------------------------------------------------------------

   665 	// use othere number for coverage increasing

   666 	lockNumber = RMmCustomAPI::EGid2;

   667 	

   668 	// data for ExpectL 

   669 	expectData.Close();

   670     ltsyData.SerialiseL(expectData);    	    

   671        

   672     iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);

   673     iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);

   674 	

   675 	customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   676 	

   677 	User::WaitForRequest(requestStatus);	

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

   679 	AssertMockLtsyStatusL();

   680 

   681  	//-------------------------------------------------------------------------

   682 	// TEST E: Unsolicited completion of RMmCustomAPI::ActivateSimLock

   683 	// from LTSY.

   684  	//-------------------------------------------------------------------------

   685 

   686 	TRequestStatus mockLtsyStatus;

   687 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   688 	iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);

   689 	User::WaitForRequest(mockLtsyStatus);

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

   691 	AssertMockLtsyStatusL();

   692 	

   693 	

   694 	//-------------------------------------------------------------------------

   695 	// just to increase coverage

   696 	//-------------------------------------------------------------------------	

   697 	// use othere number for coverage increasing

   698 	lockNumber = RMmCustomAPI::EImsi;

   699 	

   700 	// data for ExpectL	    

   701 	expectData.Close();

   702     ltsyData.SerialiseL(expectData);    	    

   703        

   704     iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);

   705     iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);

   706 	

   707 	customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   708 	

   709 	User::WaitForRequest(requestStatus);	

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

   711 	

   712 	AssertMockLtsyStatusL();

   713 	

   714 	CleanupStack::PopAndDestroy(3, this); 

   715 	

   716 	}

   717 

   718 

   719 /**

   720 @SYMTestCaseID BA-CTSY-CIPC-MCASL-0002

   721 @SYMComponent  telephony_ctsy

   722 @SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ActivateSimLock

   723 @SYMTestPriority High

   724 @SYMTestActions Invokes cancelling of RMmCustomAPI::ActivateSimLock

   725 @SYMTestExpectedResults Pass

   726 @SYMTestType CT

   727 */

   728 void CCTsyCustomIPCFU::TestActivateSimLock0002L()

   729 	{

   730 

   731 	OpenEtelServerL(EUseExtendedError);

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

   733 	OpenPhoneL();

   734 

   735 	RBuf8 expectData;

   736 	CleanupClosePushL(expectData);

   737 	

   738 	RMmCustomAPI customAPI;

   739 	OpenCustomAPILC(customAPI, iPhone);

   740 	

   741 	TRequestStatus mockLtsyStatus;

   742 	// to wait CompleteL

   743 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   744 

   745 	TRequestStatus requestStatus;

   746  	//-------------------------------------------------------------------------

   747 	// Test cancelling of RMmCustomAPI::ActivateSimLock

   748  	//-------------------------------------------------------------------------

   749  	RMmCustomAPI::TSimLockPassword password(_L("changeme"));

   750 	RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EImsi);	

   751 	

   752 	// data for ExpectL

   753 	TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > 

   754 									ltsyData(password, lockNumber);	    

   755     ltsyData.SerialiseL(expectData);    	    

   756     iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);

   757 	

   758 	customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   759 	// cancel this request

   760 	customAPI.CancelAsyncRequest(ECustomSimLockActivateIPC);

   761 	// try to complete canceled request

   762 	iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);		

   763 			

   764 	// wait for request

   765 	User::WaitForRequest(requestStatus);

   766 	// this request can't be canceled 

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

   768 	

   769 	// wait for CompleteL

   770 	User::WaitForRequest(mockLtsyStatus);

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

   772 	

   773 	AssertMockLtsyStatusL();

   774 	CleanupStack::PopAndDestroy(3, this); 	

   775 	}

   776 

   777 

   778 /**

   779 @SYMTestCaseID BA-CTSY-CIPC-MCASL-0003

   780 @SYMComponent  telephony_ctsy

   781 @SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ActivateSimLock with bad parameter data

   782 @SYMTestPriority High

   783 @SYMTestActions Invokes RMmCustomAPI::ActivateSimLock with bad parameter data

   784 @SYMTestExpectedResults Pass

   785 @SYMTestType CT

   786 */

   787 void CCTsyCustomIPCFU::TestActivateSimLock0003L()

   788 	{

   789 

   790 	OpenEtelServerL(EUseExtendedError);

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

   792 	OpenPhoneL();

   793 

   794 	RBuf8 expectData;

   795 	CleanupClosePushL(expectData);

   796 	

   797 	RMmCustomAPI customAPI;

   798 	OpenCustomAPILC(customAPI, iPhone);

   799 	

   800 	TRequestStatus requestStatus;	

   801 

   802 	//-------------------------------------------------------------------------

   803 	// Test A: Test passing wrong parameters to

   804 	// RMmCustomAPI::ActivateSimLock

   805  	//-------------------------------------------------------------------------

   806 	RMmCustomAPI::TSimLockPassword password(_L("changeme"));

   807 	RMmCustomAPI::TLockNumber lockNumber((RMmCustomAPI::TLockNumber) 0); 	

   808 	  

   809     customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   810 	

   811 	User::WaitForRequest(requestStatus);	

   812 	ASSERT_EQUALS(KErrArgument, requestStatus.Int());

   813 	AssertMockLtsyStatusL();

   814 	

   815 	CleanupStack::PopAndDestroy(3, this); 

   816 

   817 	}

   818 

   819 

   820 /**

   821 @SYMTestCaseID BA-CTSY-CIPC-MCASL-0004

   822 @SYMComponent  telephony_ctsy

   823 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ActivateSimLock

   824 @SYMTestPriority High

   825 @SYMTestActions Invokes multiple client requests to RMmCustomAPI::ActivateSimLock

   826 @SYMTestExpectedResults Pass

   827 @SYMTestType CT

   828 */

   829 void CCTsyCustomIPCFU::TestActivateSimLock0004L()

   830 	{

   831 					

   832 	OpenEtelServerL(EUseExtendedError);

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

   834 	OpenPhoneL();

   835 	

   836 	RBuf8 expectData;

   837 	CleanupClosePushL(expectData);

   838 

   839 	// Open second client

   840 	RTelServer telServer2;

   841 	TInt ret = telServer2.Connect();

   842 	ASSERT_EQUALS(KErrNone, ret);

   843 	CleanupClosePushL(telServer2);

   844 

   845 	RMobilePhone phone2;

   846 	ret = phone2.Open(telServer2,KMmTsyPhoneName);

   847 	ASSERT_EQUALS(KErrNone, ret);

   848 	CleanupClosePushL(phone2);

   849 	

   850 	RMmCustomAPI customAPI;

   851 	OpenCustomAPILC(customAPI, iPhone);

   852 	

   853 	RMmCustomAPI customAPI2;

   854 	OpenCustomAPILC(customAPI2, phone2, EFalse);

   855 	

   856 	TRequestStatus requestStatus;

   857 	TRequestStatus requestStatus2;

   858 

   859 	//-------------------------------------------------------------------------

   860 	// Test A: Test multiple clients requesting RMmCustomAPI::ActivateSimLock

   861  	//-------------------------------------------------------------------------	

   862 	// data for the first request

   863 	RMmCustomAPI::TSimLockPassword password(_L("changeme"));

   864 	RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator_Gid1);	

   865 	

   866 	// data for the second request

   867 	RMmCustomAPI::TSimLockPassword password2(_L("changeme2"));

   868 	RMmCustomAPI::TLockNumber lockNumber2(RMmCustomAPI::EOperator_Gid2);	

   869 	

   870 	// data for the first ExpectL

   871 	TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > ltsyData(password, lockNumber);	    

   872     ltsyData.SerialiseL(expectData);       

   873   		

   874 	// send first request

   875 	iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);

   876     iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);	

   877 	customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   878 		

   879 	// send second request

   880 	customAPI2.ActivateSimLock(requestStatus2, password2, lockNumber2);

   881 	

   882 	// wait for the first answer

   883 	User::WaitForRequest(requestStatus);	

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

   885 	

   886 	// wait for the second answer

   887 	User::WaitForRequest(requestStatus2);	

   888 	ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());		

   889 	

   890 	AssertMockLtsyStatusL();

   891 	// Done !

   892 	CleanupStack::PopAndDestroy(6, this); 

   893 

   894 	}

   895 

   896 

   897 /**

   898 @SYMTestCaseID BA-CTSY-CIPC-MCASL-0005

   899 @SYMComponent  telephony_ctsy

   900 @SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ActivateSimLock with timeout

   901 @SYMTestPriority High

   902 @SYMTestActions Invokes RMmCustomAPI::ActivateSimLock and tests for timeout

   903 @SYMTestExpectedResults Pass

   904 @SYMTestType CT

   905 */

   906 void CCTsyCustomIPCFU::TestActivateSimLock0005L()

   907 	{

   908 

   909 	OpenEtelServerL(EUseExtendedError);

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

   911 	OpenPhoneL();

   912 

   913 	RBuf8 expectData;

   914 	CleanupClosePushL(expectData);

   915 	

   916 	RMmCustomAPI customAPI;

   917 	OpenCustomAPILC(customAPI, iPhone);

   918 	

   919 	TRequestStatus requestStatus;

   920 

   921 	//-------------------------------------------------------------------------

   922 	// Test A: Test timeout of RMmCustomAPI::ActivateSimLock

   923  	//-------------------------------------------------------------------------

   924  	RMmCustomAPI::TSimLockPassword password(_L("changeme"));

   925 	RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator_Gid2);	

   926 	

   927 	// data for ExpectL

   928 	TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > 

   929 									ltsyData(password, lockNumber);	    

   930     ltsyData.SerialiseL(expectData);    	    

   931     iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);

   932     

   933 	customAPI.ActivateSimLock(requestStatus, password, lockNumber);

   934 	

   935 	User::WaitForRequest(requestStatus);	

   936 	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());

   937 	

   938 	AssertMockLtsyStatusL();

   939 	

   940 	// Done !

   941 	CleanupStack::PopAndDestroy(3, this); 

   942 

   943 	}

   944 

   945 

   946 /**

   947 @SYMTestCaseID BA-CTSY-CIPC-MCDASL-0001

   948 @SYMComponent  telephony_ctsy

   949 @SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DeActivateSimLock

   950 @SYMTestPriority High

   951 @SYMTestActions Invokes RMmCustomAPI::DeActivateSimLock

   952 @SYMTestExpectedResults Pass

   953 @SYMTestType CT

   954 */

   955 void CCTsyCustomIPCFU::TestDeActivateSimLock0001L()

   956 	{

   957 

   958 	OpenEtelServerL(EUseExtendedError);

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

   960 	OpenPhoneL();

   961 

   962 	RBuf8 expectData;

   963 	CleanupClosePushL(expectData);

   964 	

   965 	RMmCustomAPI customAPI;

   966 	OpenCustomAPILC(customAPI, iPhone);

   967 	

   968 	

   969 	TRequestStatus requestStatus;	

   970 	

   971  	//-------------------------------------------------------------------------

   972 	// TEST A: failure to dispatch request to LTSY

   973  	//-------------------------------------------------------------------------

   974 	RMmCustomAPI::TSimLockPassword password(_L("changeme"));

   975 	RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator);	

   976 	

   977 	// data for ExpectL

   978 	TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > 

   979 									ltsyData(password, lockNumber);	    

   980     ltsyData.SerialiseL(expectData);    	    

   981     iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData, KErrNotSupported);

   982     

   983 	customAPI.DeActivateSimLock(requestStatus, password, lockNumber);

   984 	

   985 	User::WaitForRequest(requestStatus);	

   986 	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

   987 	AssertMockLtsyStatusL();

   988 

   989 	//-------------------------------------------------------------------------

   990 	// TEST B: failure on completion of pending request from LTSY->CTSY

   991  	//-------------------------------------------------------------------------	

   992 	// use othere number for coverage increasing

   993 	lockNumber = RMmCustomAPI::EGid1;

   994 	

   995 	// data for ExpectL  

   996 	expectData.Close();

   997     ltsyData.SerialiseL(expectData);    	    

   998     iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);

   999     iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrGeneral);

  1000 	

  1001 	customAPI.DeActivateSimLock(requestStatus, password, lockNumber);

  1002 	

  1003 	User::WaitForRequest(requestStatus);	

  1004 	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

  1005 	AssertMockLtsyStatusL();

  1006 

  1007  	//-------------------------------------------------------------------------

  1008 	// TEST C: Successful completion request of

  1009 	// RMmCustomAPI::DeActivateSimLock when result is not cached.

  1010  	//-------------------------------------------------------------------------

  1011 	// use othere number for coverage increasing

  1012 	lockNumber = RMmCustomAPI::EGid2;

  1013 	

  1014 	// data for ExpectL

  1015 	expectData.Close();

  1016     ltsyData.SerialiseL(expectData);    	    

  1017        

  1018     iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);

  1019     iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);

  1020 	

  1021 	customAPI.DeActivateSimLock(requestStatus, password, lockNumber);

  1022 	

  1023 	User::WaitForRequest(requestStatus);	

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

  1025 	AssertMockLtsyStatusL();

  1026 

  1027  	//-------------------------------------------------------------------------

  1028 	// TEST E: Unsolicited completion of RMmCustomAPI::DeActivateSimLock

  1029 	// from LTSY.

  1030  	//-------------------------------------------------------------------------

  1031 	TRequestStatus mockLtsyStatus;

  1032 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

  1033 	iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);

  1034 	User::WaitForRequest(mockLtsyStatus);

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

  1036 	AssertMockLtsyStatusL();

  1037 	

  1038 	//-------------------------------------------------------------------------

  1039 	// just to increase coverage

  1040 	//-------------------------------------------------------------------------	

  1041 	// use othere number for coverage increasing

  1042 	lockNumber = RMmCustomAPI::EGlobalUnlock;

  1043 	

  1044 	// data for ExpectL	    

  1045 	expectData.Close();

  1046     ltsyData.SerialiseL(expectData);    	    

  1047        

  1048     iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);

  1049     iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);

  1050 	

  1051 	customAPI.DeActivateSimLock(requestStatus, password, lockNumber);

  1052 	

  1053 	User::WaitForRequest(requestStatus);	

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

  1055 	AssertMockLtsyStatusL();

  1056 	

  1057 	//-------------------------------------------------------------------------

  1058 	// just to increase coverage

  1059 	//-------------------------------------------------------------------------	

  1060 	// use othere number for coverage increasing

  1061 	lockNumber = RMmCustomAPI::EImsi;

  1062 	

  1063 	// data for ExpectL	    

  1064 	expectData.Close();

  1065     ltsyData.SerialiseL(expectData);    	    

  1066        

  1067     iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);

  1068     iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);

  1069 	

  1070 	customAPI.DeActivateSimLock(requestStatus, password, lockNumber);

  1071 	

  1072 	User::WaitForRequest(requestStatus);	

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

  1074 	

  1075 	

  1076 	AssertMockLtsyStatusL();

  1077 	CleanupStack::PopAndDestroy(3, this); 

  1078 	

  1079 	}

  1080 

  1081 

  1082 /**

  1083 @SYMTestCaseID BA-CTSY-CIPC-MCDASL-0002

  1084 @SYMComponent  telephony_ctsy

  1085 @SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::DeActivateSimLock

  1086 @SYMTestPriority High

  1087 @SYMTestActions Invokes cancelling of RMmCustomAPI::DeActivateSimLock

  1088 @SYMTestExpectedResults Pass

  1089 @SYMTestType CT

  1090 */

  1091 void CCTsyCustomIPCFU::TestDeActivateSimLock0002L()

  1092 	{

  1093 

  1094 	OpenEtelServerL(EUseExtendedError);

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

  1096 	OpenPhoneL();

  1097 

  1098 	RBuf8 expectData;

  1099 	CleanupClosePushL(expectData);

  1100 	

  1101 	RMmCustomAPI customAPI;

  1102 	OpenCustomAPILC(customAPI, iPhone);

  1103 

  1104 	

  1105 	TRequestStatus mockLtsyStatus;

  1106 	// to wait CompleteL

  1107 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

  1108 

  1109 	TRequestStatus requestStatus;

  1110  	//-------------------------------------------------------------------------

  1111 	// Test cancelling of RMmCustomAPI::DeActivateSimLock

  1112  	//-------------------------------------------------------------------------

  1113  	RMmCustomAPI::TSimLockPassword password(_L("changeme"));

  1114 	RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EImsi);	

  1115 	

  1116 	// data for ExpectL

  1117 	TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > 

  1118 									ltsyData(password, lockNumber);	    

  1119     ltsyData.SerialiseL(expectData);    	    

  1120     iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);

  1121 	

  1122 	customAPI.DeActivateSimLock(requestStatus, password, lockNumber);

  1123 	// cancel this request

  1124 	customAPI.CancelAsyncRequest(ECustomSimLockDeActivateIPC);

  1125 	// try to complete canceled request

  1126 	iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);		

  1127 			

  1128 	// wait for request

  1129 	User::WaitForRequest(requestStatus);

  1130 	// this request can't be canceled 

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

  1132 	

  1133 	// wait for CompleteL

  1134 	User::WaitForRequest(mockLtsyStatus);