1 // Copyright (c) 1997-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 #include <e32test.h>

    17 

    18 #include "TE_EtelMMTestStepBase.h"

    19 #include "TE_mmcall.h"

    20 #include "testdef.h"

    21 

    22 CTestCall::CTestCall()

    23 /** Each test step initialises it's own name

    24 */

    25 	{

    26 	// store the name of this test case

    27 	// this is the name that is used by the script file

    28 	SetTestStepName(_L("TestCall"));

    29 	}

    30 

    31 enum TVerdict CTestCall::doTestStepL()

    32 //

    33 // Test Call Functions

    34 //

    35     {

    36 	iTestCount =1;

    37 	INFO_PRINTF1(_L(""));

    38 	INFO_PRINTF1(_L("Test Mobile Call Functionality"));

    39 	

    40 	RMobilePhone mmPhone;

    41 	TInt ret=mmPhone.Open(iTelServer,DMMTSY_PHONE_NAME);

    42 	TEST(ret==KErrNone);

    43 

    44 	RMobileLine mmLine;

    45 	ret=mmLine.Open(mmPhone,DMMTSY_LINE_VOICE_NAME);

    46     TEST(ret==KErrNone);

    47 

    48 	RMobileCall mmCall;

    49 	TName callName;

    50 	ret=mmCall.OpenNewCall(mmLine,callName);

    51     TEST(ret==KErrNone);

    52 

    53 	TRequestStatus reqStatus;

    54 	   	

    55    	// Test DialNoFdnCheck (Overloaded)

    56 

    57 	TBuf<RMobilePhone::KMaxMobileTelNumberSize> TelNumber(DMMTSY_PHONE_TEL_NUMBER);

    58 	

    59 	// Provide standard multimode call parameter package for DialNoFdnCheck

    60 

    61 	RMobileCall::TMobileCallParamsV1  mmCallParams;

    62 	RMobileCall::TMobileCallParamsV1Pckg mmCallParamsPckg(mmCallParams);

    63 

    64 	mmCallParams.iInterval = DMMTSY_CALL_INTERVAL;

    65 	mmCallParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

    66 	mmCallParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

    67 	mmCallParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

    68 	mmCallParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

    69 	mmCallParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

    70 	mmCallParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

    71 

    72 	// First Asynchronous

    73 	mmCall.DialNoFdnCheck(reqStatus, TelNumber);

    74 	User::WaitForRequest(reqStatus);

    75    	TEST(reqStatus.Int()==KErrNone);

    76   

    77 	INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (First async) passed"), iTestCount++);

    78 

    79 	// First Asynchronous & cancel

    80 	mmCall.DialNoFdnCheck(reqStatus, TelNumber);

    81 	mmCall.CancelAsyncRequest(EMobileCallDialNoFdnCheck);

    82 

    83     User::WaitForRequest(reqStatus);

    84    	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

    85 

    86    	if (reqStatus.Int()==KErrCancel)

    87    		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (First async & cancel (Cancelled Request)) passed"), iTestCount++);

    88    	else

    89    		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (First async & cancel (Request Not Cancelled)) passed"), iTestCount++);

    90 

    91 	// Second Asynchronous

    92 	mmCall.DialNoFdnCheck(reqStatus, mmCallParamsPckg, TelNumber);

    93 	User::WaitForRequest(reqStatus);

    94    	TEST(reqStatus.Int()==KErrNone);

    95   

    96 	INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (Second async) passed"), iTestCount++);

    97 

    98 	// Second Asynchronous & cancel

    99 	mmCall.DialNoFdnCheck(reqStatus, mmCallParamsPckg, TelNumber);

   100 	mmCall.CancelAsyncRequest(EMobileCallDialNoFdnCheck);

   101 

   102     User::WaitForRequest(reqStatus);

   103    	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   104 

   105    	if (reqStatus.Int()==KErrCancel)

   106    		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (Second async & cancel (Cancelled Request)) passed"), iTestCount++);

   107    	else

   108    		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (Second async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   109 

   110 	// Test Set Call Parameters within Dial

   111 	// Create a multimode call parameter package, send it as part of Dial

   112 	mmCallParams.iInterval = DMMTSY_CALL_INTERVAL;

   113 	mmCallParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   114 	mmCallParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   115 	mmCallParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   116 	mmCallParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   117 	mmCallParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   118 	mmCallParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   119 

   120 //	TBuf<RMobilePhone::KMaxMobileTelNumberSize> number(DMMTSY_PHONE_TEL_NUMBER);

   121 	iNumber = DMMTSY_PHONE_TEL_NUMBER;

   122 	TEST(KErrNone==mmCall.Dial(mmCallParamsPckg, iNumber));

   123 	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (MM Call Params) passed"), iTestCount++);

   124 

   125 	

   126 	// Test Set Call using V2 Parameters within Dial

   127 	// Create a multimode call parameter package, send it as part of Dial

   128 	RMobileCall::TMobileCallParamsV2  mmCallParamsV2;

   129 

   130 	mmCallParamsV2.iInterval = DMMTSY_CALL_INTERVAL;

   131 	mmCallParamsV2.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   132 	mmCallParamsV2.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   133 	mmCallParamsV2.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   134 	mmCallParamsV2.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   135 	mmCallParamsV2.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   136 	mmCallParamsV2.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   137 	mmCallParamsV2.iBearerMode = DMMTSY_CALL_NEW_BEARER;

   138 

   139 	RMobileCall::TMobileCallParamsV2Pckg mmCallParamsV2Pckg(mmCallParamsV2);

   140 	TEST(KErrNone==mmCall.Dial(mmCallParamsV2Pckg, iNumber));

   141 	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (MMv2 Call Params) passed"), iTestCount++);

   142 

   143 	// Test Set Call using V7 Parameters within Dial

   144 	// Create a multimode call parameter package, send it as part of Dial

   145 	RMobileCall::TMobileCallParamsV7 mmCallParamsV7;

   146 	TEST(mmCallParamsV7.ExtensionId() == RMobileCall::KETelMobileCallParamsV7);

   147 

   148 	mmCallParamsV7.iInterval = DMMTSY_CALL_INTERVAL;

   149 	mmCallParamsV7.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   150 	mmCallParamsV7.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   151 	mmCallParamsV7.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   152 	mmCallParamsV7.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   153 	mmCallParamsV7.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   154 	mmCallParamsV7.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   155 	mmCallParamsV7.iBearerMode = DMMTSY_CALL_NEW_BEARER;

   156 	mmCallParamsV7.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

   157 	mmCallParamsV7.iSubAddress = DMMTSY_CALL_SUBADDRESS;

   158 	mmCallParamsV7.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;

   159 	mmCallParamsV7.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;

   160 	mmCallParamsV7.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;

   161 	mmCallParamsV7.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

   162 	mmCallParamsV7.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

   163 	mmCallParamsV7.iAlphaId = DMMTSY_CALL_ALPHA_ID;

   164 	

   165 	RMobileCall::TMobileCallParamsV7Pckg mmCallParamsV7Pckg(mmCallParamsV7);

   166 	TEST(KErrNone==mmCall.Dial(mmCallParamsV7Pckg, iNumber));

   167 	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (MMv7 Call Params) passed"), iTestCount++);

   168 	

   169 	// Test RMobileCall::DialCallControl with RMobileCall::TMobileCallParamsV7

   170 	

   171 	// If this test fails, ensure that the line:

   172 	// etel_KSatEngineSid 0x10281806

   173 	// is present in \epoc32\data\epoc.ini

   174 	TRequestStatus dialCallControlStatus;

   175 	mmCall.DialCallControl(dialCallControlStatus, mmCallParamsV7Pckg, iNumber);

   176 	User::WaitForRequest(dialCallControlStatus);

   177 	TEST(KErrNone==dialCallControlStatus.Int());

   178 	

   179 	// Asynchronous and cancel

   180 	mmCall.DialCallControl(dialCallControlStatus, mmCallParamsV7Pckg, iNumber);

   181 	mmCall.CancelAsyncRequest(EMobileCallDialCallControl);

   182 	User::WaitForRequest(dialCallControlStatus);

   183 	TEST(KErrNone==dialCallControlStatus.Int() || KErrCancel==dialCallControlStatus.Int());

   184 	

   185 	INFO_PRINTF2(_L("Test %d - RMobileCall::DialCallControl with RMobileCall::TMobileCallParamsV3 passed"), iTestCount++);

   186 	

   187 	// Test RMobileCall::DialCallControl with no number

   188 	TBuf<1> noNumberBuf;

   189 	noNumberBuf.Zero();

   190 	mmCall.DialCallControl(dialCallControlStatus, mmCallParamsV7Pckg, noNumberBuf);

   191 	User::WaitForRequest(dialCallControlStatus);

   192 	TEST(KErrArgument==dialCallControlStatus.Int());	

   193 	

   194 	INFO_PRINTF2(_L("Test %d - RMobileCall::DialCallControl with RMobileCall::TMobileCallParamsV3 and no number passed"), iTestCount++);

   195 	

   196 	//

   197 	

   198 	// Try to get just the core ETel API parts of the TCallParams

   199 	RCall::TCallParams coreCallParams;

   200 	RCall::TCallParamsPckg coreCallParamsPckg(coreCallParams);

   201 

   202 	TEST(KErrNone==mmCall.GetCallParams(coreCallParamsPckg));

   203 

   204 	TEST(coreCallParams.ExtensionId()==0);

   205 	TEST(coreCallParams.iInterval==DMMTSY_CALL_INTERVAL);

   206 

   207 	// Get the multimode call parameters this time

   208 	RMobileCall::TMobileCallParamsV1  mmCallParams2;

   209 	RMobileCall::TMobileCallParamsV1Pckg mmCallParams2Pckg(mmCallParams2);

   210 

   211 	TEST(KErrNone==mmCall.GetCallParams(mmCallParams2Pckg));

   212 

   213 	TEST(mmCallParams2.ExtensionId()==RMobileCall::KETelMobileCallParamsV1);

   214 	TEST(mmCallParams2.iInterval==DMMTSY_CALL_INTERVAL);

   215 	TEST(mmCallParams2.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

   216 	TEST(mmCallParams2.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

   217 	TEST(mmCallParams2.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

   218 	TEST(mmCallParams2.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

   219 	TEST(mmCallParams2.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

   220 	TEST(mmCallParams2.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

   221 

   222 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (MM Call Params) passed"), iTestCount++);

   223 

   224 	// Test GetMobileDataCallCaps

   225 	RMobileCall::TMobileCallDataCapsV1 dataCaps, asyncDataCaps;

   226 	RMobileCall::TMobileCallDataCapsV1Pckg dataCapsPckg(dataCaps);

   227 	RMobileCall::TMobileCallDataCapsV1Pckg asyncDataCapsPckg(asyncDataCaps);

   228 

   229 	TEST(mmCall.GetMobileDataCallCaps(dataCapsPckg) == KErrNone);

   230 	ValidateCallDataCaps(dataCaps);

   231 

   232 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallCaps (sync) passed"), iTestCount++);

   233 

   234 	// Test NotifyMobileDataCallCapsChange

   235 	// asynchronous

   236 	mmCall.NotifyMobileDataCallCapsChange(reqStatus,asyncDataCapsPckg);

   237   	User::WaitForRequest(reqStatus);

   238 	TEST(reqStatus.Int()==KErrNone);

   239 	ValidateCallDataCaps(asyncDataCaps);

   240 

   241 	// asynchronous & cancel

   242 	mmCall.NotifyMobileDataCallCapsChange(reqStatus,asyncDataCapsPckg);

   243 	mmCall.CancelAsyncRequest(EMobileCallNotifyMobileDataCallCapsChange);

   244   	User::WaitForRequest(reqStatus);

   245 	TEST(reqStatus.Int()==KErrNone  || reqStatus.Int()==KErrCancel);

   246 	if (reqStatus.Int()==KErrCancel)

   247 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileDataCallCapsChange (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   248 	else

   249 		{

   250 		ValidateCallDataCaps(asyncDataCaps);

   251 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileDataCallCapsChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   252 		}

   253 

   254 	// Test Set Data Call Parameters within Dial

   255 	RMobileCall::TMobileDataCallParamsV1 dataParams, retrieveDataParams;

   256 	RMobileCall::TMobileDataCallParamsV1Pckg dataParamsPckg(dataParams);

   257 	RMobileCall::TMobileDataCallParamsV1Pckg retrieveDataParamsPckg(retrieveDataParams);

   258 	

   259 	dataParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   260 	dataParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   261 	dataParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   262 	dataParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   263 	dataParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   264 	dataParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   265 	

   266 	dataParams.iService = DMMTSY_DATA_CALL_SERVICE;

   267 	dataParams.iSpeed = DMMTSY_DATA_CALL_SPEED;

   268 	dataParams.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

   269 	dataParams.iQoS = DMMTSY_DATA_CALL_QOS;

   270 	dataParams.iRLPVersion = DMMTSY_DATA_CALL_RLP;

   271 	dataParams.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

   272 	dataParams.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

   273 

   274 	mmCall.Dial(reqStatus, dataParamsPckg, iNumber);

   275 	User::WaitForRequest(reqStatus);

   276 	TEST(reqStatus.Int()==KErrNone);

   277 	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (Data Call Params) passed"), iTestCount++);

   278 	

   279 	// Test Get Data Call Params

   280 	TEST(mmCall.GetCallParams(retrieveDataParamsPckg) == KErrNone);

   281 	TEST(retrieveDataParams.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV1);

   282 

   283 	TEST(retrieveDataParams.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

   284 	TEST(retrieveDataParams.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

   285 	TEST(retrieveDataParams.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

   286 	TEST(retrieveDataParams.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

   287 	TEST(retrieveDataParams.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

   288 	TEST(retrieveDataParams.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

   289 	ValidateDataCallParams(retrieveDataParams, 0);

   290 	

   291 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (Data Call Params) passed"), iTestCount++);

   292 

   293 	// Test Set Data Call Parameters within Dial

   294 	RMobileCall::TMobileDataCallParamsV8 dataParams8, retrieveDataParams8;

   295 	RMobileCall::TMobileDataCallParamsV8Pckg dataParamsPckg8(dataParams8);

   296 	RMobileCall::TMobileDataCallParamsV8Pckg retrieveDataParamsPckg8(retrieveDataParams8);

   297 	

   298 	TEST(dataParams8.ExtensionId()== RMobileCall::KETelMobileDataCallParamsV8);

   299 	TEST(dataParams8.iCallParamOrigin == RMobileCall::EOriginatorUnknown);

   300 	TEST(dataParams8.iBCRepeatIndicator == RMobileCall::EBCAlternateMode);

   301 	

   302 	dataParams8.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   303 	dataParams8.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   304 	dataParams8.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   305 	dataParams8.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   306 	dataParams8.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   307 	dataParams8.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   308 	

   309 	dataParams8.iService = DMMTSY_DATA_CALL_SERVICE;

   310 	dataParams8.iSpeed = DMMTSY_DATA_CALL_SPEED;

   311 	dataParams8.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

   312 	dataParams8.iQoS = DMMTSY_DATA_CALL_QOS;

   313 	dataParams8.iRLPVersion = DMMTSY_DATA_CALL_RLP;

   314 	dataParams8.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

   315 	dataParams8.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

   316 	dataParams8.iBearerMode = DMMTSY_PHONE_MULTICALLBEARERMODE_NOTSUPPORTED;

   317 		

   318 	dataParams8.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

   319 	dataParams8.iSubAddress = DMMTSY_CALL_SUBADDRESS;

   320 	dataParams8.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;

   321 	dataParams8.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;

   322 	dataParams8.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;

   323 	dataParams8.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

   324 	dataParams8.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

   325 	dataParams8.iAlphaId = DMMTSY_CALL_ALPHA_ID;

   326 		

   327 		

   328 	mmCall.Dial(reqStatus, dataParamsPckg8, iNumber);

   329 	User::WaitForRequest(reqStatus);

   330 	TEST(reqStatus.Int()==KErrNone);

   331 	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (Data Call Params8) passed"), iTestCount++);

   332 		

   333 	// Test Get Data Call Params

   334 	TEST(mmCall.GetCallParams(retrieveDataParamsPckg8) == KErrNone);

   335 	TEST(retrieveDataParams8.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV8);

   336 	

   337 	TEST(retrieveDataParams8.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

   338 	TEST(retrieveDataParams8.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

   339 	TEST(retrieveDataParams8.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

   340 	TEST(retrieveDataParams8.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

   341 	TEST(retrieveDataParams8.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

   342 	TEST(retrieveDataParams8.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

   343 	

   344 	ValidateDataCallParams(retrieveDataParams8, 0);

   345 	TEST(retrieveDataParams8.iCallParamOrigin==DMMTSY_CALL_PARAM_ORIGIN);

   346 	TEST(retrieveDataParams8.iSubAddress==DMMTSY_CALL_SUBADDRESS);

   347 	TEST(retrieveDataParams8.iBearerCap1==DMMTSY_CALL_BEARER_CAP1);

   348 	TEST(retrieveDataParams8.iBearerCap2==DMMTSY_CALL_BEARER_CAP2);

   349 	TEST(retrieveDataParams8.iBCRepeatIndicator==DMMTSY_CALL_BC_REPEAT_INDICATOR);

   350 	TEST(retrieveDataParams8.iIconId.iIdentifier==DMMTSY_CALL_ICON_ID_IDENTIFIER);

   351 	TEST(retrieveDataParams8.iIconId.iQualifier==DMMTSY_CALL_ICON_ID_QUALIFIER);

   352 	TEST(retrieveDataParams8.iAlphaId==DMMTSY_CALL_ALPHA_ID);

   353 		

   354 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (Data Call Params8) passed"), iTestCount++);

   355 

   356 	// Test GetMobileDataCallRLPRange

   357 	RMobileCall::TMobileDataRLPRangesV1 rlpRanges;

   358 	RMobileCall::TMobileDataRLPRangesV1Pckg rlpRangesPckg(rlpRanges);

   359 

   360 	// asynchronous

   361 	mmCall.GetMobileDataCallRLPRange(reqStatus, DMMTSY_CALL_RLP_VERSION1, rlpRangesPckg);

   362 	User::WaitForRequest(reqStatus);

   363 	TEST(reqStatus.Int()==KErrNone);

   364 

   365 	// extract the returned rlpRanges from the package

   366 	rlpRanges = rlpRangesPckg();

   367 	ValidateRLPRange(rlpRanges);	

   368 

   369 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallRLPRange passed"), iTestCount++);

   370 	

   371 	// asynchronous & cancel

   372 	mmCall.GetMobileDataCallRLPRange(reqStatus, DMMTSY_CALL_RLP_VERSION1, rlpRangesPckg);

   373 	mmCall.CancelAsyncRequest(EMobileCallGetMobileDataCallRLPRange);

   374 	User::WaitForRequest(reqStatus);

   375 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   376 

   377 	if (reqStatus.Int()==KErrCancel)

   378 		INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallRLPRange (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   379 	else

   380 		{

   381 		// extract the returned rlpRanges from the package

   382 		rlpRanges = rlpRangesPckg();

   383 		ValidateRLPRange(rlpRanges);

   384 		INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallRLPRange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   385 		}

   386 

   387 	

   388 	// Test Set Hcsd Parameters within Dial

   389 	RMobileCall::TMobileHscsdCallParamsV1 hscsdParams, retrieveHscsdParams;

   390 	RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdParamsPckg(hscsdParams);

   391 	RMobileCall::TMobileHscsdCallParamsV1Pckg retrieveHscsdParamsPckg(retrieveHscsdParams);

   392 	

   393 	hscsdParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   394 	hscsdParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   395 	hscsdParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   396 	hscsdParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   397 	hscsdParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   398 	hscsdParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   399 	

   400 	hscsdParams.iService = DMMTSY_DATA_CALL_SERVICE;

   401 	hscsdParams.iSpeed = DMMTSY_DATA_CALL_SPEED;

   402 	hscsdParams.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

   403 	hscsdParams.iQoS = DMMTSY_DATA_CALL_QOS;

   404 	hscsdParams.iRLPVersion = DMMTSY_DATA_CALL_RLP;

   405 	hscsdParams.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

   406 	hscsdParams.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

   407 	

   408 	hscsdParams.iInterval = DMMTSY_CALL_INTERVAL;

   409 	hscsdParams.iWantedAiur = DMMTSY_CALL_HCSD_AIUR;

   410 	hscsdParams.iWantedRxTimeSlots = DMMTSY_CALL_HCSD_TS;

   411 	hscsdParams.iMaxTimeSlots = DMMTSY_CALL_HCSD_MAXTS;

   412 	hscsdParams.iCodings = DMMTSY_CALL_HCSD_CODING;

   413 	hscsdParams.iAsymmetry = DMMTSY_CALL_HCSD_ASYMMETRY;

   414 	hscsdParams.iUserInitUpgrade = DMMTSY_CALL_HCSD_USER_IMI;

   415 

   416 	// asynchronous

   417 	mmCall.Dial(reqStatus, hscsdParamsPckg, iNumber);

   418 	User::WaitForRequest(reqStatus);

   419 	TEST(reqStatus.Int()==KErrNone);

   420 	

   421 	// Set the dyanmic HSCSD params

   422 	mmCall.SetDynamicHscsdParams(reqStatus,hscsdParams.iWantedAiur,hscsdParams.iWantedRxTimeSlots);

   423 	User::WaitForRequest(reqStatus);

   424 	TEST(reqStatus.Int()==KErrNone);

   425 

   426 	// asynchronous & cancel

   427 	mmCall.SetDynamicHscsdParams(reqStatus,hscsdParams.iWantedAiur,hscsdParams.iWantedRxTimeSlots);

   428 	mmCall.CancelAsyncRequest(EMobileCallSetDynamicHscsdParams);

   429 	User::WaitForRequest(reqStatus);

   430 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   431 	if (reqStatus.Int()==KErrCancel)

   432 		INFO_PRINTF2(_L("Test %d - RMobileCall::SetDynamicHscsdParams (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   433 	else

   434 		INFO_PRINTF2(_L("Test %d - RMobileCall::SetDynamicHscsdParams (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   435 		

   436 	// Test Set Hscsd Params V7 within Dial

   437 	RMobileCall::TMobileHscsdCallParamsV7 hscsdParamsV7;

   438 	RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdParamsV7Pckg(hscsdParamsV7);

   439 	

   440 	hscsdParamsV7.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   441 	hscsdParamsV7.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   442 	hscsdParamsV7.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   443 	hscsdParamsV7.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   444 	hscsdParamsV7.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   445 	hscsdParamsV7.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   446 		

   447 	hscsdParamsV7.iService = DMMTSY_DATA_CALL_SERVICE;

   448 	hscsdParamsV7.iSpeed = DMMTSY_DATA_CALL_SPEED;

   449 	hscsdParamsV7.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

   450 	hscsdParamsV7.iQoS = DMMTSY_DATA_CALL_QOS;

   451 	hscsdParamsV7.iRLPVersion = DMMTSY_DATA_CALL_RLP;

   452 	hscsdParamsV7.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

   453 	hscsdParamsV7.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

   454 

   455 	hscsdParamsV7.iInterval = DMMTSY_CALL_INTERVAL;

   456 	hscsdParamsV7.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   457 	hscsdParamsV7.iWantedAiur = DMMTSY_CALL_HCSD_AIUR;

   458 	hscsdParamsV7.iWantedRxTimeSlots = DMMTSY_CALL_HCSD_TS;

   459 	hscsdParamsV7.iMaxTimeSlots = DMMTSY_CALL_HCSD_MAXTS;

   460 	hscsdParamsV7.iCodings = DMMTSY_CALL_HCSD_CODING;

   461 	hscsdParamsV7.iAsymmetry = DMMTSY_CALL_HCSD_ASYMMETRY;

   462 	hscsdParamsV7.iUserInitUpgrade = DMMTSY_CALL_HCSD_USER_IMI;

   463 	hscsdParamsV7.iBearerMode = DMMTSY_CALL_NEW_BEARER;

   464 	hscsdParamsV7.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

   465 	hscsdParamsV7.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

   466 	hscsdParamsV7.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

   467 	hscsdParamsV7.iAlphaId = DMMTSY_CALL_ALPHA_ID;

   468 	

   469 	// asynchronous

   470 	mmCall.Dial(reqStatus, hscsdParamsV7Pckg, iNumber);

   471 	User::WaitForRequest(reqStatus);

   472 	TEST(reqStatus.Int()==KErrNone);

   473 	

   474 	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (HSCSDv7 Call Params) passed"), iTestCount++);

   475 

   476 	// Test Get Hscsd Params

   477 	TEST(mmCall.GetCallParams(retrieveHscsdParamsPckg) == KErrNone);

   478 	TEST(retrieveHscsdParams.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV1);

   479 	

   480 	TEST(retrieveHscsdParams.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

   481 	TEST(retrieveHscsdParams.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

   482 	TEST(retrieveHscsdParams.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

   483 	TEST(retrieveHscsdParams.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

   484 	TEST(retrieveHscsdParams.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

   485 	TEST(retrieveHscsdParams.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

   486 		

   487 	ValidateHscsdParams(retrieveHscsdParams);

   488 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (HSCSD params) passed"), iTestCount++);

   489 	

   490 	// Test Set Hscsd Params V8 within Dial

   491 	RMobileCall::TMobileHscsdCallParamsV8 hscsdParams8, retrieveHscsdParams8;

   492 	RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdParamsPckg8(hscsdParams8);

   493 	RMobileCall::TMobileHscsdCallParamsV8Pckg retrieveHscsdParamsPckg8(retrieveHscsdParams8);

   494 

   495 	TEST(hscsdParams8.ExtensionId()== RMobileCall::KETelMobileHscsdCallParamsV8);

   496 	TEST(hscsdParams8.iBCRepeatIndicator == RMobileCall::EBCAlternateMode);

   497 		

   498 	hscsdParams8.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   499 	hscsdParams8.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   500 	hscsdParams8.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   501 	hscsdParams8.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   502 	hscsdParams8.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   503 	hscsdParams8.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   504 			

   505 	hscsdParams8.iService = DMMTSY_DATA_CALL_SERVICE;

   506 	hscsdParams8.iSpeed = DMMTSY_DATA_CALL_SPEED;

   507 	hscsdParams8.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

   508 	hscsdParams8.iQoS = DMMTSY_DATA_CALL_QOS;

   509 	hscsdParams8.iRLPVersion = DMMTSY_DATA_CALL_RLP;

   510 	hscsdParams8.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

   511 	hscsdParams8.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

   512 	

   513 	hscsdParams8.iInterval = DMMTSY_CALL_INTERVAL;

   514 	hscsdParams8.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   515 	hscsdParams8.iWantedAiur = DMMTSY_CALL_HCSD_AIUR;

   516 	hscsdParams8.iWantedRxTimeSlots = DMMTSY_CALL_HCSD_TS;

   517 	hscsdParams8.iMaxTimeSlots = DMMTSY_CALL_HCSD_MAXTS;

   518 	hscsdParams8.iCodings = DMMTSY_CALL_HCSD_CODING;

   519 	hscsdParams8.iAsymmetry = DMMTSY_CALL_HCSD_ASYMMETRY;

   520 	hscsdParams8.iUserInitUpgrade = DMMTSY_CALL_HCSD_USER_IMI;

   521 	hscsdParams8.iBearerMode = DMMTSY_CALL_NEW_BEARER;

   522 	hscsdParams8.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

   523 	hscsdParams8.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

   524 	hscsdParams8.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

   525 	hscsdParams8.iAlphaId = DMMTSY_CALL_ALPHA_ID;

   526 			

   527 	hscsdParams8.iSubAddress = DMMTSY_CALL_SUBADDRESS;

   528 	hscsdParams8.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;

   529 	hscsdParams8.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;

   530 	hscsdParams8.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;

   531 			

   532 	// asynchronous

   533 	mmCall.Dial(reqStatus, hscsdParamsPckg8, iNumber);

   534 	User::WaitForRequest(reqStatus);

   535 	TEST(reqStatus.Int()==KErrNone);

   536 	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (HSCSDv8 Call Params) passed"), iTestCount++);

   537 				

   538 	// Test Get Hscsd Params

   539 	TEST(mmCall.GetCallParams(retrieveHscsdParamsPckg8) == KErrNone);

   540 	TEST(retrieveHscsdParams8.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV8);

   541 

   542 	TEST(retrieveHscsdParams8.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

   543 	TEST(retrieveHscsdParams8.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

   544 	TEST(retrieveHscsdParams8.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

   545 	TEST(retrieveHscsdParams8.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

   546 	TEST(retrieveHscsdParams8.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

   547 	TEST(retrieveHscsdParams8.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

   548 	

   549 	ValidateHscsdParams(retrieveHscsdParams8);

   550 	TEST(retrieveHscsdParams8.iSubAddress == DMMTSY_CALL_SUBADDRESS);

   551 	TEST(retrieveHscsdParams8.iBearerCap1 == DMMTSY_CALL_BEARER_CAP1);

   552 	TEST(retrieveHscsdParams8.iBearerCap2 == DMMTSY_CALL_BEARER_CAP2);

   553 	TEST(retrieveHscsdParams8.iBCRepeatIndicator == DMMTSY_CALL_BC_REPEAT_INDICATOR);

   554 	

   555 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (HSCSD params) passed"), iTestCount++);

   556 				

   557 	// Test Get HSCSD Call Information with version 1

   558 	RMobileCall::TMobileCallHscsdInfoV1 hscsdInfo, asyncHscsdInfo;

   559 	RMobileCall::TMobileCallHscsdInfoV1Pckg hscsdInfoPckg(hscsdInfo);

   560 	RMobileCall::TMobileCallHscsdInfoV1Pckg asyncHscsdInfoPckg(asyncHscsdInfo);

   561 

   562 	TEST(mmCall.GetCurrentHscsdInfo(hscsdInfoPckg) == KErrNone);

   563 	ValidateHscsdInfo(hscsdInfo);

   564 

   565 	// Test Get HSCSD Call Information with version 7

   566 	RMobileCall::TMobileCallHscsdInfoV7 hscsdInfoV7;

   567 	RMobileCall::TMobileCallHscsdInfoV7Pckg hscsdInfoV7Pckg(hscsdInfoV7);

   568 	TEST(mmCall.GetCurrentHscsdInfo(hscsdInfoV7Pckg) == KErrNone);

   569 	

   570 	ValidateHscsdInfo(hscsdInfoV7);

   571 	TEST(hscsdInfoV7.iCallParamOrigin == DMMTSY_CALL_PARAM_ORIGIN);

   572 	TEST(hscsdInfoV7.iIconId.iQualifier == DMMTSY_CALL_ICON_ID_QUALIFIER);

   573 	TEST(hscsdInfoV7.iIconId.iIdentifier == DMMTSY_CALL_ICON_ID_IDENTIFIER);

   574 	TEST(hscsdInfoV7.iAlphaId == DMMTSY_CALL_ALPHA_ID);

   575 	TEST(hscsdInfoV7.iParamsCallControlModified == DMMTSY_CALL_PARAMS_CALL_CONTROL_MODIFIED);

   576 	

   577 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCurrentHscsdInfo (sync) passed"), iTestCount++);

   578 

   579 	// Test Get HSCSD Call Information with version 8

   580 	RMobileCall::TMobileCallHscsdInfoV8 hscsdInfoV8;

   581 	RMobileCall::TMobileCallHscsdInfoV8Pckg hscsdInfoV8Pckg(hscsdInfoV8);

   582 	TEST(mmCall.GetCurrentHscsdInfo(hscsdInfoV8Pckg) == KErrNone);

   583 	

   584 	ValidateHscsdInfo(hscsdInfoV8);

   585 	TEST(hscsdInfoV8.iCallParamOrigin == DMMTSY_CALL_PARAM_ORIGIN);

   586 	TEST(hscsdInfoV8.iIconId.iQualifier == DMMTSY_CALL_ICON_ID_QUALIFIER);

   587 	TEST(hscsdInfoV8.iIconId.iIdentifier == DMMTSY_CALL_ICON_ID_IDENTIFIER);

   588 	TEST(hscsdInfoV8.iAlphaId == DMMTSY_CALL_ALPHA_ID);

   589 	TEST(hscsdInfoV8.iParamsCallControlModified == DMMTSY_CALL_PARAMS_CALL_CONTROL_MODIFIED);

   590 	TEST(hscsdInfoV8.iSubAddress == DMMTSY_CALL_SUBADDRESS);

   591 	TEST(hscsdInfoV8.iBearerCap1 == DMMTSY_CALL_BEARER_CAP1);

   592 	TEST(hscsdInfoV8.iBearerCap2 == DMMTSY_CALL_BEARER_CAP2);

   593 	TEST(hscsdInfoV8.iBCRepeatIndicator == DMMTSY_CALL_BC_REPEAT_INDICATOR);

   594 	

   595 	

   596 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCurrentHscsdInfo (sync) passed"), iTestCount++);

   597 

   598 	

   599 	// Test Notify Hscsd Info Change

   600 	// asynchronous

   601 	mmCall.NotifyHscsdInfoChange(reqStatus,asyncHscsdInfoPckg);

   602 	User::WaitForRequest(reqStatus);

   603 	TEST(reqStatus.Int()==KErrNone);

   604 	ValidateHscsdInfo(asyncHscsdInfo);

   605 

   606 	// asynchronous & cancel

   607 	mmCall.NotifyHscsdInfoChange(reqStatus,asyncHscsdInfoPckg);

   608 	mmCall.CancelAsyncRequest(EMobileCallNotifyHscsdInfoChange);

   609 	User::WaitForRequest(reqStatus);

   610 	TEST(reqStatus.Int()==KErrNone  || reqStatus.Int()==KErrCancel);

   611 	if (reqStatus.Int()==KErrCancel)

   612 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyHscsdInfoChange (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   613 	else

   614 		{

   615 		ValidateHscsdInfo(asyncHscsdInfo);

   616 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyHscsdInfoChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   617 		}

   618 	

   619 	// Close Call

   620 	mmCall.Close();

   621 	mmLine.Close();

   622 	mmPhone.Close();

   623 	INFO_PRINTF1(_L(""));

   624 

   625 	return TestStepResult();

   626 	}

   627 

   628 CTestCallb::CTestCallb()

   629 /** Each test step initialises it's own name

   630 */

   631 	{

   632 	// store the name of this test case

   633 	// this is the name that is used by the script file

   634 	SetTestStepName(_L("TestCall-2nd-part"));

   635 	}

   636 

   637 enum TVerdict CTestCallb::doTestStepL()

   638 //

   639 // Test Call Functions

   640 //

   641     {

   642 	iTestCount =1;

   643 	INFO_PRINTF1(_L(""));

   644 	INFO_PRINTF1(_L("Test Mobile Call Functionality"));

   645 //	LOGTEXT(_L8("Test Mobile Call Functionality"));

   646 	

   647 	RMobilePhone mmPhone;

   648 	TInt ret=mmPhone.Open(iTelServer,DMMTSY_PHONE_NAME);

   649 	TEST(ret==KErrNone);

   650 

   651 	RMobileLine mmLine;

   652 	ret=mmLine.Open(mmPhone,DMMTSY_LINE_VOICE_NAME);

   653     TEST(ret==KErrNone);

   654 

   655 	RMobileCall mmCall;

   656 	TName callName;

   657 	ret=mmCall.OpenNewCall(mmLine,callName);

   658     TEST(ret==KErrNone);

   659 

   660 	TRequestStatus reqStatus;

   661 

   662    	// Test DialNoFdnCheck (Overloaded)

   663 	

   664 	// Provide stndard multimode call parameter package for DialNoFdnCheck

   665 

   666 	RMobileCall::TMobileCallParamsV1  mmCallParams;

   667 

   668 	mmCallParams.iInterval = DMMTSY_CALL_INTERVAL;

   669 	mmCallParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

   670 	mmCallParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

   671 	mmCallParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

   672 	mmCallParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

   673 	mmCallParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

   674 	mmCallParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

   675 

   676 //	test.Next(_L("OK: RMobileCall's HSCSD Call Info"));

   677 

   678 	// Test Voice Fallback for Multimedia Calls

   679 

   680 	TName falbackCallName;

   681 

   682 	// asynchronous 

   683 

   684 	mmCall.NotifyVoiceFallback(reqStatus, falbackCallName);

   685 	User::WaitForRequest(reqStatus);

   686 	TEST(reqStatus.Int()==KErrNone);

   687 	TEST(falbackCallName.Compare(DMMTSY_VOICE_FALLBACK_CALL_NAME) == 0);

   688 

   689 	// asynchronous & cancel

   690 

   691 	mmCall.NotifyVoiceFallback(reqStatus, falbackCallName);

   692 	mmCall.CancelAsyncRequest(EMobileCallNotifyVoiceFallback);

   693 	User::WaitForRequest(reqStatus);

   694 	TEST(reqStatus.Int()==KErrNone  || reqStatus.Int()==KErrCancel);

   695 	if (reqStatus.Int()==KErrCancel)

   696 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyVoiceFallback (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   697 	else

   698 		{

   699 		TEST(falbackCallName.Compare(DMMTSY_VOICE_FALLBACK_CALL_NAME) == 0);

   700 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyVoiceFallback (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   701 		}

   702 	

   703 //	test.Next(_L("OK: RMobileCall's Voice Fallback"));

   704 

   705 

   706 	// Test SwitchAlternating Data Call

   707 

   708 	// asynchronous

   709 

   710 	mmCall.SwitchAlternatingCall(reqStatus);

   711 	User::WaitForRequest(reqStatus);

   712 	TEST(reqStatus.Int()==KErrNone);

   713 

   714 	// asynchronous & cancel

   715 

   716 	mmCall.SwitchAlternatingCall(reqStatus);

   717 	mmCall.CancelAsyncRequest(EMobileCallSwitchAlternatingCall);

   718 	User::WaitForRequest(reqStatus);

   719 	TEST(reqStatus.Int()==KErrNone  || reqStatus.Int()==KErrCancel);

   720 	if (reqStatus.Int()==KErrCancel)

   721 		INFO_PRINTF2(_L("Test %d - RMobileCall::SwitchAlternatingCall (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   722 	else

   723 		INFO_PRINTF2(_L("Test %d - RMobileCall::SwitchAlternatingCall (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   724 

   725 	

   726 	// Test Notify Alternating Call Switch

   727 

   728 	// asynchronous 

   729 

   730 	mmCall.NotifyAlternatingCallSwitch(reqStatus);

   731 	User::WaitForRequest(reqStatus);

   732 	TEST(reqStatus.Int()==KErrNone);

   733 

   734 	// asynchronous & cancel

   735 

   736 	mmCall.NotifyAlternatingCallSwitch(reqStatus);

   737 	mmCall.CancelAsyncRequest(EMobileCallNotifyAlternatingCallSwitch);

   738 	User::WaitForRequest(reqStatus);

   739 	TEST(reqStatus.Int()==KErrNone  || reqStatus.Int()==KErrCancel);

   740 	if (reqStatus.Int()==KErrCancel)

   741 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyAlternatingCallSwitch (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   742 	else

   743 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyAlternatingCallSwitch (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   744 		

   745 //	test.Next(_L("OK: RMobileCall's Alternating Calls"));

   746 

   747 	// Call Control caps

   748 	

   749 	RMobileCall::TMobileCallCapsV1 callCaps;

   750 	RMobileCall::TMobileCallCapsV1Pckg callCapsPckg(callCaps);

   751 

   752 	// synchronous

   753 

   754 	TEST(mmCall.GetMobileCallCaps(callCapsPckg)==KErrNone);

   755 	TEST(callCaps.iCallControlCaps==DMMTSY_CALL_CONTROL_CAPS1);

   756 	TEST(callCaps.iCallEventCaps==DMMTSY_CALL_EVENT_CAPS1);

   757 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallCaps (sync) passed"), iTestCount++);

   758 

   759 	// asynchronous

   760 

   761 	mmCall.NotifyMobileCallCapsChange(reqStatus, callCapsPckg);

   762    	User::WaitForRequest(reqStatus);

   763 	TEST(reqStatus.Int()==KErrNone);

   764 	TEST(callCaps.iCallControlCaps==DMMTSY_CALL_CONTROL_CAPS2);

   765 	TEST(callCaps.iCallEventCaps==DMMTSY_CALL_EVENT_CAPS2);

   766 

   767 	// asynchronous & cancel

   768 

   769 	mmCall.NotifyMobileCallCapsChange(reqStatus, callCapsPckg);

   770 	mmCall.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);

   771    	User::WaitForRequest(reqStatus);

   772 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   773 	if (reqStatus.Int()==KErrCancel)

   774 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallCapsChange (async & cancel (Cancelled Request)) passed"), iTestCount++);	

   775 	else

   776 		{

   777 		TEST(callCaps.iCallControlCaps==DMMTSY_CALL_CONTROL_CAPS2);

   778 		TEST(callCaps.iCallEventCaps==DMMTSY_CALL_EVENT_CAPS2);

   779 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallCapsChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   780 		}

   781 

   782 	// Call Status

   783 

   784 	RMobileCall::TMobileCallStatus callStatus;

   785 

   786 	// synchronous

   787 

   788 	TEST(KErrNone==mmCall.GetMobileCallStatus(callStatus));

   789 	TEST(callStatus==DMMTSY_CALL_STATUS1);

   790 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallStatus (sync) passed"), iTestCount++);

   791 	

   792 	// asynchronous

   793 

   794 	mmCall.NotifyMobileCallStatusChange(reqStatus,callStatus);

   795    	User::WaitForRequest(reqStatus);

   796 	TEST(reqStatus.Int()==KErrNone);

   797 	TEST(callStatus==DMMTSY_CALL_STATUS2);

   798 

   799 	// asynchronous & cancel

   800 

   801 	mmCall.NotifyMobileCallStatusChange(reqStatus,callStatus);

   802 	mmCall.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);

   803    	User::WaitForRequest(reqStatus);

   804 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   805 	if (reqStatus.Int()==KErrCancel)

   806 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallStatusChange (async & cancel (Cancelled Request)) passed"), iTestCount++);

   807 	else

   808 		{

   809 		TEST(callStatus==DMMTSY_CALL_STATUS2);

   810 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallStatusChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   811 		}

   812 

   813 	// Call Hold

   814 	

   815 	// asynchronous

   816 

   817 	mmCall.Hold(reqStatus);

   818    	User::WaitForRequest(reqStatus);

   819 	TEST(reqStatus.Int()==KErrNone);

   820 

   821 	// asynchronous & cancel

   822 

   823 	mmCall.Hold(reqStatus);

   824 	mmCall.CancelAsyncRequest(EMobileCallHold);

   825    	User::WaitForRequest(reqStatus);

   826 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   827 	if (reqStatus.Int()==KErrCancel)

   828 		INFO_PRINTF2(_L("Test %d - RMobileCall::Hold (async & cancel (Cancelled Request)) passed"), iTestCount++);

   829 	else

   830 		INFO_PRINTF2(_L("Test %d - RMobileCall::Hold (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   831 

   832 	// Call Resume

   833 

   834 	// asynchronous

   835 

   836 	mmCall.Resume(reqStatus);

   837    	User::WaitForRequest(reqStatus);

   838 	TEST(reqStatus.Int()==KErrNone);

   839 

   840 	// asynchronous & cancel

   841 

   842 	mmCall.Resume(reqStatus);

   843 	mmCall.CancelAsyncRequest(EMobileCallResume);

   844    	User::WaitForRequest(reqStatus);

   845 	TEST(reqStatus.Int()==KErrNone  || reqStatus.Int()==KErrCancel);

   846 	if (reqStatus.Int()==KErrCancel)

   847 		INFO_PRINTF2(_L("Test %d - RMobileCall::Resume (async & cancel (Cancelled Request)) passed"), iTestCount++);

   848 	else

   849 		INFO_PRINTF2(_L("Test %d - RMobileCall::Resume (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   850 

   851 	// Call Swap

   852 

   853 	// asynchronous

   854 

   855 	mmCall.Swap(reqStatus);

   856    	User::WaitForRequest(reqStatus);

   857 	TEST(reqStatus.Int()==KErrNone);

   858 

   859 	// asynchronous & cancel

   860 

   861 	mmCall.Swap(reqStatus);

   862 	mmCall.CancelAsyncRequest(EMobileCallSwap);

   863    	User::WaitForRequest(reqStatus);

   864 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   865 	if (reqStatus.Int()==KErrCancel)

   866 		INFO_PRINTF2(_L("Test %d - RMobileCall::Swap (async & cancel (Cancelled Request)) passed"), iTestCount++);

   867 	else

   868 		INFO_PRINTF2(_L("Test %d - RMobileCall::Swap (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   869 

   870 	

   871 	// Call Deflect

   872 

   873 	RMobilePhone::TMobileAddress deflectAddress;

   874 	RMobileCall::TMobileCallDeflect deflectType=DMMTSY_CALL_DEFLECT_TYPE;

   875 

   876 	deflectAddress.iTypeOfNumber = DMMTSY_PHONE_TON;

   877 	deflectAddress.iNumberPlan = DMMTSY_PHONE_NPI;

   878 	deflectAddress.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

   879 

   880 	// asynchronous

   881 

   882 	mmCall.Deflect(reqStatus,deflectType,deflectAddress);

   883 	User::WaitForRequest(reqStatus);

   884 	TEST(reqStatus.Int()==KErrNone);

   885 

   886 	// asynchronous & cancel

   887 

   888 	mmCall.Deflect(reqStatus,deflectType,deflectAddress);

   889 	mmCall.CancelAsyncRequest(EMobileCallDeflect);

   890 	User::WaitForRequest(reqStatus);

   891 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   892 	if (reqStatus.Int()==KErrCancel)

   893 		INFO_PRINTF2(_L("Test %d - RMobileCall::Deflect (async & cancel (Cancelled Request)) passed"), iTestCount++);

   894 	else

   895 		INFO_PRINTF2(_L("Test %d - RMobileCall::Deflect (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   896 

   897 

   898 	// Call Transfer

   899 

   900 	// asynchronous

   901 

   902 	mmCall.Transfer(reqStatus);

   903 	User::WaitForRequest(reqStatus);

   904 	TEST(reqStatus.Int()==KErrNone);

   905 

   906 	// asynchronous & cancel

   907 

   908 	mmCall.Transfer(reqStatus);

   909 	mmCall.CancelAsyncRequest(EMobileCallTransfer);

   910 	User::WaitForRequest(reqStatus);

   911 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   912 	if (reqStatus.Int()==KErrCancel)

   913 		INFO_PRINTF2(_L("Test %d - RMobileCall::Transfer (async & cancel (Cancelled Request)) passed"), iTestCount++);

   914 	else

   915 		INFO_PRINTF2(_L("Test %d - RMobileCall::Transfer (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   916 

   917 	// Call Go one to one

   918 

   919 	// asynchronous

   920 

   921 	mmCall.GoOneToOne(reqStatus);

   922 	User::WaitForRequest(reqStatus);

   923 	TEST(reqStatus.Int()==KErrNone);

   924 

   925 	// asynchronous & cancel

   926 

   927 	mmCall.GoOneToOne(reqStatus);

   928 	mmCall.CancelAsyncRequest(EMobileCallGoOneToOne);

   929 	User::WaitForRequest(reqStatus);

   930 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   931 	if (reqStatus.Int()==KErrCancel)

   932 		INFO_PRINTF2(_L("Test %d - RMobileCall::GoOneToOne (async & cancel (Cancelled Request)) passed"), iTestCount++);

   933 	else

   934 		INFO_PRINTF2(_L("Test %d - RMobileCall::GoOneToOne (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   935 

   936 	// asynchronous

   937 

   938 	RMobileCall::TMobileCallEvent event;

   939 	mmCall.NotifyCallEvent(reqStatus, event);

   940    	User::WaitForRequest(reqStatus);

   941 	TEST(reqStatus.Int()==KErrNone);

   942 	TEST(event==DMMTSY_CALL_EVENT1);

   943 

   944 	// asynchronous & cancel

   945 

   946 	mmCall.NotifyCallEvent(reqStatus, event);

   947 	mmCall.CancelAsyncRequest(EMobileCallNotifyCallEvent);

   948    	User::WaitForRequest(reqStatus);

   949 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   950 	if (reqStatus.Int()==KErrCancel)

   951 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyCallEvent (async & cancel (Cancelled Request)) passed"), iTestCount++);

   952 	else

   953 		{

   954 		TEST(event==DMMTSY_CALL_EVENT1);

   955 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyCallEvent (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

   956 		}

   957 

   958 	// Get the big block of call information

   959 

   960 	RMobileCall::TMobileCallInfoV1 syncCallInfo;

   961 	RMobileCall::TMobileCallInfoV1Pckg syncCallInfoPckg(syncCallInfo);

   962 	

   963 	// synchronous

   964 

   965 	TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckg));

   966 	syncCallInfo = syncCallInfoPckg();

   967 	

   968 	ValidateMobileCallInfo(syncCallInfo);

   969 	

   970 	//repeat for V3

   971 	RMobileCall::TMobileCallInfoV3 syncCallInfoV3;

   972 	RMobileCall::TMobileCallInfoV3Pckg syncCallInfoPckgV3(syncCallInfoV3);

   973 	

   974 	TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckgV3));

   975 	ValidateMobileCallInfo(syncCallInfoV3);

   976 	

   977 	TEST(syncCallInfoV3.iSecurity == DMMTSY_CALL_SECURITY);

   978 

   979 	//repeat for V7

   980 	RMobileCall::TMobileCallInfoV7 syncCallInfoV7;

   981 	RMobileCall::TMobileCallInfoV7Pckg syncCallInfoPckgV7(syncCallInfoV7);

   982 	TEST(syncCallInfoV7.ExtensionId() == KEtelExtMultimodeV7);

   983 	

   984 	TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckgV7));

   985 	ValidateMobileCallInfo(syncCallInfoV7);

   986 	

   987 	TEST(syncCallInfoV7.iSecurity == DMMTSY_CALL_SECURITY);

   988 	TEST(syncCallInfoV7.iCallParamOrigin == DMMTSY_CALL_ORIGIN);

   989 	TEST(syncCallInfoV7.iIconId.iQualifier  == DMMTSY_CALL_ICON_ID_QUALIFIER);

   990 	TEST(syncCallInfoV7.iIconId.iIdentifier  == DMMTSY_CALL_ICON_ID_IDENTIFIER);	

   991 	TEST(syncCallInfoV7.iAlphaId == DMMTSY_CALL_ALPHA_ID);

   992 

   993 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallInfo (sync) passed"), iTestCount++);

   994 

   995 	//repeat for V8

   996 	RMobileCall::TMobileCallInfoV8 syncCallInfoV8;

   997 	RMobileCall::TMobileCallInfoV8Pckg syncCallInfoPckgV8(syncCallInfoV8);

   998 	TEST(syncCallInfoV8.ExtensionId() == KEtelExtMultimodeV8);

   999 	TEST(syncCallInfoV8.iBCRepeatIndicator == RMobileCall::EBCAlternateMode);

  1000 		

  1001 	TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckgV8));

  1002 	ValidateMobileCallInfo(syncCallInfoV8);

  1003 		

  1004 	TEST(syncCallInfoV8.iSubAddress == DMMTSY_CALL_SUBADDRESS);

  1005 	TEST(syncCallInfoV8.iBearerCap1 == DMMTSY_CALL_BEARER_CAP1);

  1006 	TEST(syncCallInfoV8.iBearerCap2  == DMMTSY_CALL_BEARER_CAP2);

  1007 	TEST(syncCallInfoV8.iBCRepeatIndicator  == DMMTSY_CALL_BC_REPEAT_INDICATOR);	

  1008 

  1009 	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallInfo (sync) passed"), iTestCount++);

  1010 

  1011 	

  1012 	// Close Call

  1013 	mmCall.Close();

  1014 	mmLine.Close();

  1015 	mmPhone.Close();

  1016 	INFO_PRINTF1(_L(""));

  1017 

  1018 	return TestStepResult();

  1019 	}

  1020 

  1021 CTestCallc::CTestCallc()

  1022 /** Each test step initialises it's own name

  1023 */

  1024 	{

  1025 	// store the name of this test case

  1026 	// this is the name that is used by the script file

  1027 	SetTestStepName(_L("TestCall-3rd-part"));

  1028 	}

  1029 

  1030 enum TVerdict CTestCallc::doTestStepL()

  1031 //

  1032 // Test Call Functions

  1033 //

  1034     {

  1035 	iTestCount =1;

  1036 	INFO_PRINTF1(_L(""));

  1037 	INFO_PRINTF1(_L("Test Mobile Call Functionality"));

  1038 //	LOGTEXT(_L8("Test Mobile Call Functionality"));

  1039 	

  1040 	RMobilePhone mmPhone;

  1041 	TInt ret=mmPhone.Open(iTelServer,DMMTSY_PHONE_NAME);

  1042 	TEST(ret==KErrNone);

  1043 

  1044 	RMobileLine mmLine;

  1045 	ret=mmLine.Open(mmPhone,DMMTSY_LINE_VOICE_NAME);

  1046     TEST(ret==KErrNone);

  1047 

  1048 	RMobileCall mmCall;

  1049 	TName callName;

  1050 	ret=mmCall.OpenNewCall(mmLine,callName);

  1051     TEST(ret==KErrNone);

  1052 

  1053 	TRequestStatus reqStatus;

  1054 

  1055    	// Test DialNoFdnCheck (Overloaded)

  1056 

  1057 	// Provide stndard multimode call parameter package for DialNoFdnCheck

  1058 

  1059 	RMobileCall::TMobileCallParamsV1  mmCallParams;

  1060 	RMobileCall::TMobileCallParamsV1Pckg mmCallParamsPckg(mmCallParams);

  1061 

  1062 	mmCallParams.iInterval = DMMTSY_CALL_INTERVAL;

  1063 	mmCallParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

  1064 	mmCallParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

  1065 	mmCallParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

  1066 	mmCallParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

  1067 	mmCallParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

  1068 	mmCallParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

  1069 

  1070 	// Notify Call Event

  1071 

  1072 

  1073 	//test.next(_L("OK: RMobileCall's MobileCallControl"));

  1074 

  1075 	// Notify Remote Party Info change

  1076 	

  1077 	RMobileCall::TMobileCallRemotePartyInfoV1 remoteParty;

  1078 	RMobileCall::TMobileCallRemotePartyInfoV1Pckg remotePartyPckg(remoteParty);

  1079 

  1080 	// asynchronous

  1081 

  1082 	mmCall.NotifyRemotePartyInfoChange(reqStatus, remotePartyPckg);

  1083    	User::WaitForRequest(reqStatus);

  1084 	TEST(reqStatus.Int()==KErrNone);

  1085 

  1086 	remoteParty=remotePartyPckg();

  1087 	ValidateRemotePartyInfoChange(remoteParty);

  1088 

  1089 	// asynchronous & cancel

  1090 

  1091 	mmCall.NotifyRemotePartyInfoChange(reqStatus, remotePartyPckg);

  1092 	mmCall.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);

  1093    	User::WaitForRequest(reqStatus);

  1094 	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

  1095 	if (reqStatus.Int()==KErrCancel)

  1096 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyRemotePartyInfoChange (async & cancel (Cancelled Request)) passed"), iTestCount++);

  1097 	else

  1098 		{

  1099 		remoteParty=remotePartyPckg();

  1100 		ValidateRemotePartyInfoChange(remoteParty);

  1101 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyRemotePartyInfoChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

  1102 		}

  1103 

  1104 	//test.next(_L("OK: RMobileCall's MobileCallInformation"));

  1105 

  1106 	// Test Privacy functional unit

  1107 

  1108 	RMobilePhone::TMobilePhonePrivacy asyncPrivacy;

  1109 	

  1110 	// Test Set Privacy Privacy

  1111 

  1112 	TEST(mmCall.SetPrivacy(DMMTSY_CALL_SET_PRIVACY) == KErrNone);

  1113 	INFO_PRINTF2(_L("Test %d - RMobileCall::SetPrivacy (sync) passed"), iTestCount++);

  1114 

  1115 	// Test Notify Privacy Confirmation

  1116 

  1117 	// asynchronous

  1118 

  1119 	mmCall.NotifyPrivacyConfirmation(reqStatus, asyncPrivacy);

  1120 	User::WaitForRequest(reqStatus);

  1121 	TEST(reqStatus.Int() == KErrNone);

  1122 	TEST(asyncPrivacy == DMMTSY_CALL_SET_PRIVACY);

  1123 

  1124 	// asynchronous & cancel

  1125 

  1126 	mmCall.NotifyPrivacyConfirmation(reqStatus, asyncPrivacy);

  1127 	mmCall.CancelAsyncRequest(EMobileCallNotifyPrivacyConfirmation);

  1128 	User::WaitForRequest(reqStatus);

  1129 	TEST(reqStatus.Int() == KErrNone || reqStatus.Int() == KErrCancel);

  1130 	if (reqStatus.Int() == KErrNone)

  1131 		{

  1132 		TEST(asyncPrivacy == DMMTSY_CALL_SET_PRIVACY);

  1133 		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyPrivacyConfirmation (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

  1134 		}

  1135 	else