1 // Copyright (c) 2007-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 // The TEFUnit test suite for DataCallControl in the Common TSY.

    15 // 

    16 //

    17 

    18 /**

    19  @file 

    20 */

    21 

    22 #include "cctsydatacallcontrolfu.h"

    23 #include <etel.h>

    24 #include <etelmm.h>

    25 #include <et_clsvr.h>

    26 #include <ctsy/mmtsy_names.h>

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

    28 #include "tmockltsydata.h"

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

    30 #include "MmTsy_Csd_Defs.h"

    31 #include <featmgr/featurecontrol.h>

    32 #include <featureuids.h>

    33 

    34 CTestSuite* CCTsyDataCallControlFU::CreateSuiteL(const TDesC& aName)

    35 	{

    36 	SUB_SUITE;

    37 

    38 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetBearerServiceInfo0001L);

    39 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetBearerServiceInfo0006L);

    40 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetBearerServiceInfo0011L);

    41 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0001L);

    42 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0006L);

    43 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0007L);

    44 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0008L);

    45 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0009L);

    46 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0011L);

    47 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0012L);

    48 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0013L);

    49 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0014L);

    50 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0001L);

    51 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0006L);

    52 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0008L);

    53 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0011L);

    54 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyVoiceFallback0001L);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyVoiceFallback0006L);

    56 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyVoiceFallback00011L);

    57 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps0001L);

    58 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps0006L);

    59 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps0008L);

    60 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps00011L);

    61 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0001L);

    62 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0006L);

    63 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0007L);

    64 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0008L);

    65 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0009L);

    66 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange00011L);

    67 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0001L);

    68 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0006L);

    69 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0007L);

    70 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0009L);

    71 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams00010L);

    72 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams00011L);

    73 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallRLPRange0001L);

    74 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallRLPRange0006L);

    75 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallRLPRange00011L);

    76 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0001L);

    77 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0006L);

    78 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0007L);

    79 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0008L);

    80 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0009L);

    81 	ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange00011L);

    82 

    83 	END_SUITE;

    84 	}

    85 

    86 

    87 //

    88 // Actual test cases

    89 //

    90 

    91 

    92 /**

    93 @SYMTestCaseID BA-CTSY-DATC-CGBSI-0001

    94 @SYMComponent  telephony_ctsy

    95 @SYMTestCaseDesc Test support in CTSY for RCall::GetBearerServiceInfo for voice calls

    96 @SYMTestPriority High

    97 @SYMTestActions Invokes RCall::GetBearerServiceInfo for voice calls

    98 @SYMTestExpectedResults Pass

    99 @SYMTestType CT

   100 */

   101 void CCTsyDataCallControlFU::TestGetBearerServiceInfo0001L()

   102 	{

   103 

   104 	OpenEtelServerL(EUseExtendedError);

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

   106 	OpenPhoneL();

   107 

   108  	//-------------------------------------------------------------------------

   109 	// TEST: failure to dispatch request to CTSY

   110 	// because RCall::GetBearerServiceInfo is not supported for voice calls

   111  	//-------------------------------------------------------------------------

   112 	

   113 	RCall call;

   114 	RLine line;

   115 	OpenLineLC(line, KMmTsyVoice1LineName);

   116 	OpenNewCallLC(line, call);

   117 	DialL(call, 1, RMobilePhone::EVoiceService);

   118 	RCall::TBearerService bearerService;

   119 	TInt res = call.GetBearerServiceInfo(bearerService);

   120 	ASSERT_EQUALS(KErrNotSupported, res)

   121 	AssertMockLtsyStatusL();

   122 

   123 	// same test for voice call from auxiliary voice line

   124 	RCall call2;

   125 	RLine line2;

   126 	OpenLineLC(line2, KMmTsyVoice2LineName);

   127 	OpenNewCallLC(line2, call2);

   128 	DialL(call2, 2, RMobilePhone::EAuxVoiceService);

   129 	res = call2.GetBearerServiceInfo(bearerService);

   130 	ASSERT_EQUALS(KErrNotSupported, res)

   131 	AssertMockLtsyStatusL();

   132 

   133 	CleanupStack::PopAndDestroy(5, this); // call2, line2, call, line, this

   134 	

   135 	}

   136 

   137 /**

   138 @SYMTestCaseID BA-CTSY-DATC-CGBSI-0006

   139 @SYMComponent  telephony_ctsy

   140 @SYMTestCaseDesc Test support in CTSY for RCall::GetBearerServiceInfo for data calls

   141 @SYMTestPriority High

   142 @SYMTestActions Invokes RCall::GetBearerServiceInfo for data calls

   143 @SYMTestExpectedResults Pass

   144 @SYMTestType CT

   145 */

   146 void CCTsyDataCallControlFU::TestGetBearerServiceInfo0006L()

   147 	{

   148 

   149 	OpenEtelServerL(EUseExtendedError);

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

   151 	OpenPhoneL();

   152 

   153 	RBuf8 data;

   154 	CleanupClosePushL(data);

   155 

   156 	RLine line;

   157 	RCall call;

   158 	OpenLineLC(line, KMmTsyDataLineName);

   159 	OpenNewCallLC(line, call);

   160 

   161  	//-------------------------------------------------------------------------

   162 	// TEST: failure to dispatch request to CTSY

   163 	// when call is not active

   164  	//-------------------------------------------------------------------------

   165 

   166 	RCall::TBearerService bearerService;

   167 	TInt res = call.GetBearerServiceInfo(bearerService);

   168 	ASSERT_EQUALS(KErrNotFound, res);

   169 	AssertMockLtsyStatusL();

   170 	

   171  	//-------------------------------------------------------------------------

   172 	// TEST C: Successful completion request of

   173 	// RCall::GetBearerServiceInfo.

   174  	//-------------------------------------------------------------------------

   175 

   176 	DialL(call, 1, RMobilePhone::ECircuitDataService);

   177 	ChangeCallStatusL(1, RMobilePhone::ECircuitDataService, RMobileCall::EStatusConnected);

   178 	

   179 	res = call.GetBearerServiceInfo(bearerService);

   180 	ASSERT_EQUALS(KErrNone, res)

   181 	ASSERT_EQUALS((TUint32) (RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown), bearerService.iBearerCaps)

   182 	ASSERT_EQUALS(RCall::EBearerDataUnknown, bearerService.iBearerSpeed)

   183 	AssertMockLtsyStatusL();

   184 	

   185 	// change data in CTSY

   186 	RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

   187 	RCall::TBearerService changeBearerService;

   188 	changeBearerService.iBearerCaps = RCall::KBearerCapsProtocolALT_CELLULAR;

   189 	changeBearerService.iBearerSpeed = RCall::EBearerData57600;

   190 	

   191 	TMockLtsyCallData1<RCall::TBearerService> mockBearerData(1, mobileService, changeBearerService);

   192 	data.Close();

   193 	mockBearerData.SerialiseL(data);

   194 	

   195 	TRequestStatus mockLtsyStatus;

   196 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   197 	iMockLTSY.CompleteL(EEtelCallGetBearerServiceInfo, KErrNone, data);

   198 	User::WaitForRequest(mockLtsyStatus);

   199 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())

   200 		

   201 	// test again

   202 	res = call.GetBearerServiceInfo(bearerService);

   203 	ASSERT_EQUALS(KErrNone, res);

   204 	ASSERT_EQUALS((TUint32) (RCall::KBearerCapsProtocolALT_CELLULAR), bearerService.iBearerCaps)

   205 	ASSERT_EQUALS(RCall::EBearerData57600, bearerService.iBearerSpeed)

   206 	AssertMockLtsyStatusL();

   207 

   208 	ChangeCallStatusL(1, RMobilePhone::ECircuitDataService, RMobileCall::EStatusIdle, KErrGsmReleaseByUser);

   209 	

   210 	CleanupStack::PopAndDestroy(4, this); // call, line, data, this

   211 	

   212 	}

   213 

   214 

   215 /**

   216 @SYMTestCaseID BA-CTSY-DATC-CGBSI-0011

   217 @SYMComponent  telephony_ctsy

   218 @SYMTestCaseDesc Test support in CTSY for RCall::GetBearerServiceInfo for fax calls

   219 @SYMTestPriority High

   220 @SYMTestActions Invokes RCall::GetBearerServiceInfo for fax calls

   221 @SYMTestExpectedResults Pass

   222 @SYMTestType CT

   223 */

   224 void CCTsyDataCallControlFU::TestGetBearerServiceInfo0011L()

   225 	{

   226 

   227 	OpenEtelServerL(EUseExtendedError);

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

   229 	OpenPhoneL();

   230 

   231 	RBuf8 data;

   232 	CleanupClosePushL(data);

   233 	

   234 	RBuf8 expectData;

   235     CleanupClosePushL(expectData);

   236 

   237 	RBuf8 completeData;

   238     CleanupClosePushL(completeData);

   239     

   240 	RLine line;

   241 	RCall call;

   242 	OpenLineLC(line, KMmTsyFaxLineName);

   243 	OpenNewCallLC(line, call);

   244 	

   245 	RCall::TBearerService bearerService;

   246 	TInt res = call.GetBearerServiceInfo(bearerService);

   247 	ASSERT_EQUALS(KErrNotFound, res);

   248 	AssertMockLtsyStatusL();

   249 

   250 	CleanupStack::PopAndDestroy(&call);

   251 

   252 	TName name;

   253 	RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

   254 	CreateIncomingCallL(line, 1, KNullDesC, name, mobileService, RMobileCall::EStatusConnected);

   255 	res = call.OpenExistingCall(line, name);

   256 	ASSERT_EQUALS(KErrNone, res);

   257 	CleanupClosePushL(call);

   258 	

   259  	//-------------------------------------------------------------------------

   260 	// TEST C: Successful completion request of

   261 	// RCall::GetBearerServiceInfo.

   262  	//-------------------------------------------------------------------------

   263 

   264 	res = call.GetBearerServiceInfo(bearerService);

   265 	ASSERT_EQUALS(KErrNone, res)

   266 	ASSERT_EQUALS((TUint32) (RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown), bearerService.iBearerCaps)

   267 	ASSERT_EQUALS(RCall::EBearerDataUnknown, bearerService.iBearerSpeed)

   268 	AssertMockLtsyStatusL();

   269 	

   270 	// change data in CTSY

   271 	RCall::TBearerService changeBearerService;

   272 	changeBearerService.iBearerCaps = RCall::KBearerCapsProtocolALT_CELLULAR;

   273 	changeBearerService.iBearerSpeed = RCall::EBearerData57600;

   274 	

   275 	TMockLtsyCallData1<RCall::TBearerService> mockBearerData(1, mobileService, changeBearerService);

   276 	data.Close();

   277 	mockBearerData.SerialiseL(data);

   278 	

   279 	TRequestStatus mockLtsyStatus;

   280 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   281 	iMockLTSY.CompleteL(EEtelCallGetBearerServiceInfo, KErrNone, data);

   282 	User::WaitForRequest(mockLtsyStatus);

   283 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())

   284 	AssertMockLtsyStatusL();

   285 	

   286 	// test again

   287 	res = call.GetBearerServiceInfo(bearerService);

   288 	ASSERT_EQUALS(KErrNone, res);

   289 	ASSERT_EQUALS((TUint32) (RCall::KBearerCapsProtocolALT_CELLULAR), bearerService.iBearerCaps)

   290 	ASSERT_EQUALS(RCall::EBearerData57600, bearerService.iBearerSpeed)

   291 	AssertMockLtsyStatusL();

   292 	

   293 	// Fax call is not in idle state while closing the call object.

   294 	// Therefore CTSY sends HangUp request to LTSY.

   295 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   296 	TInt hangUpCause = KErrGsmReleaseByUser;

   297 	TBool autoStChangeDisable = EFalse;

   298     TMockLtsyCallData2<TInt, TBool> mockData2(1, RMobilePhone::EFaxService, hangUpCause, autoStChangeDisable);

   299     mockData2.SerialiseL(expectData);

   300     iMockLTSY.ExpectL(EEtelCallHangUp, expectData);

   301     

   302     TMockLtsyCallData0 mockData0(1, RMobilePhone::EFaxService);

   303 	mockData0.SerialiseL(completeData);

   304 	iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);

   305 	

   306 	call.Close();

   307 	User::WaitForRequest(mockLtsyStatus);

   308 	CleanupStack::Pop(&call);

   309 	

   310 	AssertMockLtsyStatusL();

   311 	

   312  	//-------------------------------------------------------------------------

   313 	// TEST: failure to dispatch request to CTSY

   314 	// when call is not active

   315  	//-------------------------------------------------------------------------

   316 	

   317 	OpenNewCallLC(line, call);

   318 	

   319 	res = call.GetBearerServiceInfo(bearerService);

   320 	ASSERT_EQUALS(KErrNotFound, res);

   321 	AssertMockLtsyStatusL();

   322 

   323 	CleanupStack::PopAndDestroy(6, this); // data, expectData, completeData, call, line, this

   324 	

   325 	}

   326 

   327 

   328 

   329 /**

   330 @SYMTestCaseID BA-CTSY-DATC-CC-0001

   331 @SYMComponent  telephony_ctsy

   332 @SYMTestCaseDesc Test support in CTSY for RCall::Connect for voice calls

   333 @SYMTestPriority High

   334 @SYMTestActions Invokes RCall::Connect for voice calls

   335 @SYMTestExpectedResults Pass

   336 @SYMTestType CT

   337 */

   338 void CCTsyDataCallControlFU::TestConnect0001L()

   339 	{

   340 

   341 	OpenEtelServerL(EUseExtendedError);

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

   343 	OpenPhoneL();

   344 

   345 	RLine line;

   346 	RCall call;

   347 	OpenLineLC(line, KMmTsyVoice1LineName);

   348 	OpenNewCallLC(line, call);

   349 

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

   351 	// TEST: failure to dispatch request to CTSY

   352 	// because RCall::Connect is not supported for voice calls

   353  	//-------------------------------------------------------------------------

   354 

   355 	// synchronous version

   356 	TInt res = call.Connect();

   357 	ASSERT_EQUALS(KErrNotSupported, res)

   358 

   359 	// synchronous version with parameters

   360 	RCall::TCallParams callParams;

   361 	RCall::TCallParamsPckg callParamsPckg(callParams);

   362 	res = call.Connect(callParamsPckg);

   363 	ASSERT_EQUALS(KErrNotSupported, res)

   364 	

   365 	// asynchronous version

   366 	TRequestStatus reqStatus;

   367 	call.Connect(reqStatus);

   368 	User::WaitForRequest(reqStatus);

   369 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

   370 

   371 	// asynchronous version with parameters

   372 	call.Connect(reqStatus, callParamsPckg);

   373 	User::WaitForRequest(reqStatus);

   374 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

   375 

   376 	CleanupStack::PopAndDestroy(2); // call, line

   377 

   378 	// same test for voice call from auxiliary voice line

   379 	OpenLineLC(line, KMmTsyVoice2LineName);

   380 	OpenNewCallLC(line, call);

   381 

   382 	// synchronous version

   383 	res = call.Connect();

   384 	ASSERT_EQUALS(KErrNotSupported, res)

   385 	

   386 	// synchronous version with parameters

   387 	res = call.Connect(callParamsPckg);

   388 	ASSERT_EQUALS(KErrNotSupported, res)

   389 	

   390 	// asynchronous version

   391 	call.Connect(reqStatus);

   392 	User::WaitForRequest(reqStatus);

   393 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

   394 

   395 	// asynchronous version with parameters

   396 	call.Connect(reqStatus, callParamsPckg);

   397 	User::WaitForRequest(reqStatus);

   398 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

   399 

   400 	CleanupStack::PopAndDestroy(3, this); // call, line, this

   401 	

   402 	}

   403 

   404 

   405 /**

   406 @SYMTestCaseID BA-CTSY-DATC-CC-0006

   407 @SYMComponent  telephony_ctsy

   408 @SYMTestCaseDesc Test support in CTSY for RCall::Connect for data calls

   409 @SYMTestPriority High

   410 @SYMTestActions Invokes RCall::Connect for data calls

   411 @SYMTestExpectedResults Pass

   412 @SYMTestType CT

   413 */

   414 void CCTsyDataCallControlFU::TestConnect0006L()

   415 	{

   416 

   417 	OpenEtelServerL(EUseExtendedError);

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

   419 	OpenPhoneL();

   420 

   421 	RLine line;

   422 	RCall call;

   423 	OpenLineLC(line, KMmTsyDataLineName);

   424 	OpenNewCallLC(line, call);

   425 

   426  	//-------------------------------------------------------------------------

   427 	// TEST C: Successful completion request of

   428 	// RCall::Connect.

   429  	//-------------------------------------------------------------------------

   430 

   431 	TRequestStatus reqStatus;

   432 		

   433 	// synchronous version with no parameters

   434 	TInt res = call.Connect();

   435 	ASSERT_EQUALS(KErrNone, res)

   436 

   437 	// synchronous version with RCall::TCallParams parameter

   438 	RCall::TCallParams callParams;

   439 	callParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOff;

   440 	callParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeOff;

   441 	callParams.iInterval = 0;

   442 	callParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;

   443 	RCall::TCallParamsPckg callParamsPckg(callParams);

   444 	res = call.Connect(callParamsPckg);

   445 	ASSERT_EQUALS(KErrNone, res)

   446 	

   447 	// synchronous version with RMobileCall::TMobileCallParamsV1Pckg parameter

   448 	RMobileCall::TMobileCallParamsV1 mobileCallParams;

   449 	mobileCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;

   450 	mobileCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;

   451 	mobileCallParams.iInterval = 0;

   452 	mobileCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;

   453 	mobileCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

   454 	mobileCallParams.iCug.iExplicitInvoke = EFalse;

   455 	mobileCallParams.iCug.iCugIndex = -1;

   456 	mobileCallParams.iCug.iSuppressOA = EFalse;

   457 	mobileCallParams.iCug.iSuppressPrefCug = EFalse;

   458 	mobileCallParams.iAutoRedial = EFalse;

   459 	RMobileCall::TMobileCallParamsV1Pckg mobileCallParamsPckg(mobileCallParams);

   460 

   461 	res = call.Connect(mobileCallParamsPckg);

   462 	ASSERT_EQUALS(KErrNone, res)

   463 

   464 	// synchronous version with RMobileCall::TMobileDataCallParamsV1Pckg parameter

   465 	RMobileCall::TMobileDataCallParamsV1 dataCallParams;

   466 	dataCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;

   467 	dataCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;

   468 	dataCallParams.iInterval = 0;

   469 	dataCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;

   470 	dataCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

   471 	dataCallParams.iCug.iExplicitInvoke = EFalse;

   472 	dataCallParams.iCug.iCugIndex = -1;

   473 	dataCallParams.iCug.iSuppressOA = EFalse;

   474 	dataCallParams.iCug.iSuppressPrefCug = EFalse;

   475 	dataCallParams.iAutoRedial = EFalse;

   476 	dataCallParams.iService = RMobileCall::EServiceDataCircuitAsync;

   477 	dataCallParams.iSpeed = RMobileCall::ESpeedAutobauding;

   478 	dataCallParams.iProtocol = RMobileCall::EProtocolV32;

   479 	dataCallParams.iQoS = RMobileCall::EQoSTransparent;

   480 	dataCallParams.iRLPVersion = RMobileCall::ERLPNotRequested;

   481 	dataCallParams.iModemToMSWindowSize = 100;

   482 	dataCallParams.iMSToModemWindowSize = 100;

   483 	dataCallParams.iAckTimer = 100;

   484 	dataCallParams.iRetransmissionAttempts = 3;

   485 	dataCallParams.iResequencingPeriod = 100;

   486 	dataCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   487 	dataCallParams.iV42bisCodewordsNum = 2;

   488 	dataCallParams.iV42bisMaxStringLength = 64;

   489 	dataCallParams.iUseEdge = EFalse;

   490 	RMobileCall::TMobileDataCallParamsV1Pckg dataCallParamsPckg(dataCallParams);

   491 

   492 	res = call.Connect(dataCallParamsPckg);

   493 	ASSERT_EQUALS(KErrNone, res)

   494 

   495 	// asynchronous version with RMobileCall::TMobileHscsdCallParamsV1 parameter

   496 	RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams;

   497 	RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdCallParamsPckg(hscsdCallParams);

   498 	

   499 	hscsdCallParams.iService = RMobileCall::EServiceDataCircuitAsync;

   500 	hscsdCallParams.iSpeed = RMobileCall::ESpeedAutobauding;

   501 	hscsdCallParams.iProtocol = RMobileCall::EProtocolV32;

   502 	hscsdCallParams.iQoS = RMobileCall::EQoSTransparent;

   503 	hscsdCallParams.iRLPVersion = RMobileCall::ERLPNotRequested;

   504 	hscsdCallParams.iModemToMSWindowSize = 100;

   505 	hscsdCallParams.iMSToModemWindowSize = 100;

   506 	hscsdCallParams.iAckTimer = 100;

   507 	hscsdCallParams.iRetransmissionAttempts = 3;

   508 	hscsdCallParams.iResequencingPeriod = 100;

   509 	hscsdCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   510 	hscsdCallParams.iV42bisCodewordsNum = 2;

   511 	hscsdCallParams.iV42bisMaxStringLength = 64;

   512 	hscsdCallParams.iUseEdge = EFalse;

   513 	hscsdCallParams.iWantedAiur = RMobileCall::EAiurBps19200;

   514 	hscsdCallParams.iWantedRxTimeSlots = 2;

   515 	hscsdCallParams.iMaxTimeSlots = 3;

   516 	hscsdCallParams.iCodings = RMobileCall::KCapsAiurCoding96;

   517 	hscsdCallParams.iAsymmetry = RMobileCall::EAsymmetryDownlink;

   518 	hscsdCallParams.iUserInitUpgrade = ETrue;

   519 	

   520 

   521 	call.Connect(reqStatus, hscsdCallParamsPckg);

   522 	User::WaitForRequest(reqStatus);

   523 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   524 		

   525 	

   526 	//-------------------------------------------------------------------------

   527 	// Test: Test passing RMobileCall::TMobileDataCallParamsV2 to

   528 	// RCall::Connect

   529 	//-------------------------------------------------------------------------

   530 						

   531 	RMobileCall::TMobileDataCallParamsV2 callParams2;

   532 	RMobileCall::TMobileDataCallParamsV2Pckg callParamsPckg2(callParams2);

   533 					

   534 	callParams2.iService = RMobileCall::EServiceDataCircuitAsync;

   535 	callParams2.iSpeed = RMobileCall::ESpeedAutobauding;

   536 	callParams2.iProtocol = RMobileCall::EProtocolV32;

   537 	callParams2.iQoS = RMobileCall::EQoSTransparent;

   538 	callParams2.iRLPVersion = RMobileCall::ERLPNotRequested;

   539 	callParams2.iModemToMSWindowSize = 100;

   540 	callParams2.iMSToModemWindowSize = 100;

   541 	callParams2.iAckTimer = 100;

   542 	callParams2.iRetransmissionAttempts = 3;

   543 	callParams2.iResequencingPeriod = 100;

   544 	callParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   545 	callParams2.iV42bisCodewordsNum = 2;

   546 	callParams2.iV42bisMaxStringLength = 64;

   547 	callParams2.iUseEdge = EFalse;

   548 	callParams2.iBearerMode = RMobileCall::EMulticallNotSupported;

   549 		

   550 	call.Connect(reqStatus, callParamsPckg2);

   551 	User::WaitForRequest(reqStatus);

   552 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   553 			

   554 	//-------------------------------------------------------------------------

   555 	// Test: Test passing RMobileCall::TMobileDataCallParamsV8 to

   556 	// RCall::Connect

   557 	//-------------------------------------------------------------------------

   558 					

   559 	RMobileCall::TMobileDataCallParamsV8 callParams8;

   560 	RMobileCall::TMobileDataCallParamsV8Pckg callParamsPckg8(callParams8);

   561 			

   562 	callParams8.iService = RMobileCall::EServiceDataCircuitAsync;

   563 	callParams8.iSpeed = RMobileCall::ESpeedAutobauding;

   564 	callParams8.iProtocol = RMobileCall::EProtocolV32;

   565 	callParams8.iQoS = RMobileCall::EQoSTransparent;

   566 	callParams8.iRLPVersion = RMobileCall::ERLPNotRequested;

   567 	callParams8.iModemToMSWindowSize = 100;

   568 	callParams8.iMSToModemWindowSize = 100;

   569 	callParams8.iAckTimer = 100;

   570 	callParams8.iRetransmissionAttempts = 3;

   571 	callParams8.iResequencingPeriod = 100;

   572 	callParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   573 	callParams8.iV42bisCodewordsNum = 2;

   574 	callParams8.iV42bisMaxStringLength = 64;

   575 	callParams8.iUseEdge = EFalse;

   576 			

   577 	callParams8.iBearerMode = RMobileCall::EMulticallNotSupported;

   578 	callParams8.iCallParamOrigin = RMobileCall::EOriginatorUnknown ;

   579 	callParams8.iSubAddress.Zero() ;

   580 	callParams8.iBearerCap1.Zero();

   581 	callParams8.iBearerCap2.Zero();

   582 	callParams8.iBCRepeatIndicator = RMobileCall::EBCServiceChangeAndFallbackMode ;

   583 	callParams8.iAlphaId.Copy(_L("Alpha Id"));

   584 		

   585 	call.Connect(reqStatus, callParamsPckg8);

   586 	User::WaitForRequest(reqStatus);

   587 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   588 		

   589 	//-------------------------------------------------------------------------

   590 	// Test: Test passing RMobileCall::TMobileHscsdCallParamsV2 to

   591 	// RCall::Connect

   592 	//-------------------------------------------------------------------------

   593 

   594 	RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2;

   595 	RMobileCall::TMobileHscsdCallParamsV2Pckg hscsdCallParamsPckg2(hscsdCallParams2);

   596 				

   597 	hscsdCallParams2.iService = RMobileCall::EServiceDataCircuitAsync;

   598 	hscsdCallParams2.iSpeed = RMobileCall::ESpeedAutobauding;

   599 	hscsdCallParams2.iProtocol = RMobileCall::EProtocolV32;

   600 	hscsdCallParams2.iQoS = RMobileCall::EQoSTransparent;

   601 	hscsdCallParams2.iRLPVersion = RMobileCall::ERLPNotRequested;

   602 	hscsdCallParams2.iModemToMSWindowSize = 100;

   603 	hscsdCallParams2.iMSToModemWindowSize = 100;

   604 	hscsdCallParams2.iAckTimer = 100;

   605 	hscsdCallParams2.iRetransmissionAttempts = 3;

   606 	hscsdCallParams2.iResequencingPeriod = 100;

   607 	hscsdCallParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   608 	hscsdCallParams2.iV42bisCodewordsNum = 2;

   609 	hscsdCallParams2.iV42bisMaxStringLength = 64;

   610 	hscsdCallParams2.iUseEdge = EFalse;

   611 	hscsdCallParams2.iWantedRxTimeSlots = 3;

   612 				

   613 	hscsdCallParams2.iBearerMode = RMobileCall::EMulticallNotSupported;

   614 	

   615 	call.Connect(reqStatus, hscsdCallParamsPckg2);

   616 	User::WaitForRequest(reqStatus);

   617 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   618 	

   619 	//-------------------------------------------------------------------------

   620    	// Test: Test passing RMobileCall::TMobileHscsdCallParamsV7 to

   621    	// RCall::Connect

   622    	//-------------------------------------------------------------------------

   623 

   624    	RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7;

   625    	RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdCallParamsPckg7(hscsdCallParams7);

   626     

   627    	hscsdCallParams7.iService = RMobileCall::EServiceDataCircuitAsync;

   628    	hscsdCallParams7.iSpeed = RMobileCall::ESpeedAutobauding;

   629    	hscsdCallParams7.iProtocol = RMobileCall::EProtocolV32;

   630    	hscsdCallParams7.iQoS = RMobileCall::EQoSTransparent;

   631    	hscsdCallParams7.iRLPVersion = RMobileCall::ERLPNotRequested;

   632    	hscsdCallParams7.iModemToMSWindowSize = 100;

   633    	hscsdCallParams7.iMSToModemWindowSize = 100;

   634    	hscsdCallParams7.iAckTimer = 100;

   635    	hscsdCallParams7.iRetransmissionAttempts = 3;

   636    	hscsdCallParams7.iResequencingPeriod = 100;

   637    	hscsdCallParams7.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   638    	hscsdCallParams7.iV42bisCodewordsNum = 2;

   639    	hscsdCallParams7.iV42bisMaxStringLength = 64;

   640    	hscsdCallParams7.iUseEdge = EFalse;

   641    	hscsdCallParams7.iWantedRxTimeSlots = 3;

   642     			

   643    	hscsdCallParams7.iBearerMode = RMobileCall::EMulticallNotSupported;

   644    	hscsdCallParams7.iCallParamOrigin = RMobileCall::EOriginatorUnknown;

   645    	hscsdCallParams7.iIconId.iQualifier = RMobileCall::ENoIconId;

   646    	hscsdCallParams7.iIconId.iIdentifier = 2;

   647    	hscsdCallParams7.iAlphaId.Zero();

   648 	    		

   649    	call.Connect(reqStatus, hscsdCallParamsPckg7);

   650    	User::WaitForRequest(reqStatus);

   651    	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   652    	

   653 	//-------------------------------------------------------------------------

   654 	// Test: Test passing RMobileCall::TMobileHscsdCallParamsV8 to

   655 	// RCall::Connect

   656 	//-------------------------------------------------------------------------

   657 

   658 	RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8;

   659 	RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdCallParamsPckg8(hscsdCallParams8);

   660 	

   661 	hscsdCallParams8.iService = RMobileCall::EServiceDataCircuitAsync;

   662 	hscsdCallParams8.iSpeed = RMobileCall::ESpeedAutobauding;

   663 	hscsdCallParams8.iProtocol = RMobileCall::EProtocolV32;

   664 	hscsdCallParams8.iQoS = RMobileCall::EQoSTransparent;

   665 	hscsdCallParams8.iRLPVersion = RMobileCall::ERLPNotRequested;

   666 	hscsdCallParams8.iModemToMSWindowSize = 100;

   667 	hscsdCallParams8.iMSToModemWindowSize = 100;

   668 	hscsdCallParams8.iAckTimer = 100;

   669 	hscsdCallParams8.iRetransmissionAttempts = 3;

   670 	hscsdCallParams8.iResequencingPeriod = 100;

   671 	hscsdCallParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   672 	hscsdCallParams8.iV42bisCodewordsNum = 2;

   673 	hscsdCallParams8.iV42bisMaxStringLength = 64;

   674 	hscsdCallParams8.iUseEdge = EFalse;

   675 	hscsdCallParams8.iWantedRxTimeSlots = 3;

   676 			

   677 	hscsdCallParams8.iBearerMode = RMobileCall::EMulticallNotSupported;

   678 	hscsdCallParams8.iCallParamOrigin = RMobileCall::EOriginatorUnknown;

   679 	hscsdCallParams8.iIconId.iQualifier = RMobileCall::ENoIconId;

   680 	hscsdCallParams8.iIconId.iIdentifier = 2;

   681 	hscsdCallParams8.iAlphaId.Zero();

   682 		

   683 	hscsdCallParams8.iSubAddress.Zero();

   684 	hscsdCallParams8.iBearerCap1.Zero();

   685 	hscsdCallParams8.iBearerCap2.Zero();

   686 	hscsdCallParams8.iBCRepeatIndicator = RMobileCall::EBCServiceChangeAndFallbackMode ;

   687 

   688 	call.Connect(reqStatus, hscsdCallParamsPckg8);

   689 	User::WaitForRequest(reqStatus);

   690 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   691 	

   692 	CleanupStack::PopAndDestroy(3, this); // call, line, this

   693 	

   694 	}

   695 

   696 /**

   697 @SYMTestCaseID BA-CTSY-DATC-CC-0007

   698 @SYMComponent  telephony_ctsy

   699 @SYMTestCaseDesc Test support in CTSY for cancelling of RCall::Connect for data calls

   700 @SYMTestPriority High

   701 @SYMTestActions Invokes cancelling of RCall::Connect for data calls

   702 @SYMTestExpectedResults Pass

   703 @SYMTestType CT

   704 */

   705 void CCTsyDataCallControlFU::TestConnect0007L()

   706 	{

   707 

   708 	OpenEtelServerL(EUseExtendedError);

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

   710 	OpenPhoneL();

   711 

   712 	RLine line;

   713 	RCall call;

   714 	OpenLineLC(line, KMmTsyDataLineName);

   715 	OpenNewCallLC(line, call);

   716 

   717  	//-------------------------------------------------------------------------

   718 	// Test cancelling of RCall::Connect (Not Supported)

   719  	//-------------------------------------------------------------------------

   720 

   721 	RMobileCall::TMobileCallParamsV1 mobileCallParams;

   722 	mobileCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;

   723 	mobileCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;

   724 	mobileCallParams.iInterval = 0;

   725 	mobileCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;

   726 	mobileCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

   727 	mobileCallParams.iCug.iExplicitInvoke = EFalse;

   728 	mobileCallParams.iCug.iCugIndex = -1;

   729 	mobileCallParams.iCug.iSuppressOA = EFalse;

   730 	mobileCallParams.iCug.iSuppressPrefCug = EFalse;

   731 	mobileCallParams.iAutoRedial = EFalse;

   732 	RMobileCall::TMobileCallParamsV1Pckg mobileCallParamsPckg(mobileCallParams);

   733 

   734 	TRequestStatus reqStatus;

   735 	call.Connect(reqStatus, mobileCallParamsPckg);

   736 

   737 	// Cancels connecting of a (data) call.

   738 	call.ConnectCancel();

   739 	

   740 	User::WaitForRequest(reqStatus);

   741 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   742 	AssertMockLtsyStatusL();

   743 

   744 	CleanupStack::PopAndDestroy(3, this); // call, line, this

   745 	

   746 	}

   747 

   748 /**

   749 @SYMTestCaseID BA-CTSY-DATC-CC-0008

   750 @SYMComponent  telephony_ctsy

   751 @SYMTestCaseDesc Test support in CTSY for RCall::Connect with bad parameter data for data calls

   752 @SYMTestPriority High

   753 @SYMTestActions Invokes RCall::Connect with bad parameter data for data calls

   754 @SYMTestExpectedResults Pass

   755 @SYMTestType CT

   756 */

   757 void CCTsyDataCallControlFU::TestConnect0008L()

   758 	{

   759 

   760 	OpenEtelServerL(EUseExtendedError);

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

   762 	OpenPhoneL();

   763 

   764 	RLine line;

   765 	RCall call;

   766 	OpenLineLC(line, KMmTsyDataLineName);

   767 	OpenNewCallLC(line, call);

   768 

   769 	//-------------------------------------------------------------------------

   770 	// Test B: Test passing wrong descriptor size to parameter in

   771 	// RCall::Connect

   772  	//-------------------------------------------------------------------------

   773 

   774 	_LIT8(KOneCharDesc,"1");

   775 	TBuf8<1> buf(KOneCharDesc);

   776 	TInt res = call.Connect(buf);

   777 	// Passing a small buffer to function does cause an error.

   778 	ASSERT_EQUALS(KErrArgument, res)

   779 	

   780 	TRequestStatus reqStatus;

   781 	call.Connect(reqStatus, buf);

   782 	User::WaitForRequest(reqStatus);

   783 	// Passing a small buffer to function does cause an error.

   784 	ASSERT_EQUALS(KErrArgument, reqStatus.Int())

   785 	

   786 

   787 	CleanupStack::PopAndDestroy(3, this); // call, line, this

   788 	

   789 	}

   790 

   791 /**

   792 @SYMTestCaseID BA-CTSY-DATC-CC-0009

   793 @SYMComponent  telephony_ctsy

   794 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::Connect for data calls

   795 @SYMTestPriority High

   796 @SYMTestActions Invokes multiple client requests to RCall::Connect for data calls

   797 @SYMTestExpectedResults Pass

   798 @SYMTestType CT

   799 */

   800 void CCTsyDataCallControlFU::TestConnect0009L()

   801 	{

   802 

   803 	OpenEtelServerL(EUseExtendedError);

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

   805 	OpenPhoneL();

   806 

   807 	RLine line;

   808 	RCall call;

   809 	OpenLineLC(line, KMmTsyDataLineName);

   810 	OpenNewCallLC(line, call);

   811 	

   812 	RLine line2;

   813 	RCall call2;

   814 	OpenLineLC(line2, KMmTsyDataLineName);

   815 	OpenNewCallLC(line2, call2);

   816 

   817 	TRequestStatus reqStatus;

   818 	TRequestStatus reqStatus2;

   819 	

   820 	RMobileCall::TMobileDataCallParamsV1 callParams;

   821 	callParams.iService = RMobileCall::EServiceDataCircuitAsync;

   822 	callParams.iSpeed = RMobileCall::ESpeedAutobauding;

   823 	callParams.iProtocol = RMobileCall::EProtocolV32;

   824 	callParams.iQoS = RMobileCall::EQoSTransparent;

   825 	callParams.iRLPVersion = RMobileCall::ERLPNotRequested;

   826 	callParams.iModemToMSWindowSize = 100;

   827 	callParams.iMSToModemWindowSize = 100;

   828 	callParams.iAckTimer = 100;

   829 	callParams.iRetransmissionAttempts = 3;

   830 	callParams.iResequencingPeriod = 100;

   831 	callParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   832 	callParams.iV42bisCodewordsNum = 2;

   833 	callParams.iV42bisMaxStringLength = 64;

   834 	callParams.iUseEdge = EFalse;

   835 	

   836 	RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);

   837 	

   838 	//-------------------------------------------------------------------------

   839 	// Test A: Test multiple clients requesting RCall::Connect

   840  	//-------------------------------------------------------------------------

   841 

   842 	call.Connect(reqStatus, callParamsPckg);

   843 	call2.Connect(reqStatus2, callParamsPckg);

   844 

   845 	User::WaitForRequest(reqStatus);

   846 	User::WaitForRequest(reqStatus2);

   847 

   848 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   849 	ASSERT_EQUALS(KErrNone, reqStatus2.Int())

   850 

   851 	AssertMockLtsyStatusL();

   852 	CleanupStack::PopAndDestroy(5, this); // call2, line2, call, line, this

   853 	

   854 	}

   855 

   856 /**

   857 @SYMTestCaseID BA-CTSY-DATC-CC-0011

   858 @SYMComponent  telephony_ctsy

   859 @SYMTestCaseDesc Test support in CTSY for RCall::Connect for fax calls

   860 @SYMTestPriority High

   861 @SYMTestActions Invokes RCall::Connect for fax calls

   862 @SYMTestExpectedResults Pass

   863 @SYMTestType CT

   864 */

   865 void CCTsyDataCallControlFU::TestConnect0011L()

   866 	{

   867 

   868 	OpenEtelServerL(EUseExtendedError);

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

   870 	OpenPhoneL();

   871 

   872 	RLine line;

   873 	RCall call;

   874 	OpenLineLC(line, KMmTsyFaxLineName);

   875 	OpenNewCallLC(line, call);

   876 

   877  	//-------------------------------------------------------------------------

   878 	// TEST C: Successful completion request of

   879 	// RCall::Connect.

   880  	//-------------------------------------------------------------------------

   881 

   882 	// synchronous version

   883 	TInt res = call.Connect();

   884 	

   885 	// RCall::Connect() without call parameters is not supported by CTSY. 

   886 	// Because of this it is completed with KErrArgument.

   887 	ASSERT_EQUALS(KErrArgument, res)

   888 

   889 	// asynchronous version

   890 	TRequestStatus reqStatus;

   891 	call.Connect(reqStatus);

   892 	User::WaitForRequest(reqStatus);

   893 	

   894 	// RCall::Connect() without call parameters is not supported by CTSY. 

   895 	// Because of this it is completed with KErrArgument.

   896 	ASSERT_EQUALS(KErrArgument, reqStatus.Int())

   897 

   898 	// synchronous version with RMobileCall::TMobileDataCallParamsV1Pckg parameter

   899 	RMobileCall::TMobileDataCallParamsV1 callParams;

   900 	callParams.iService = RMobileCall::EServiceDataCircuitAsync;

   901 	callParams.iSpeed = RMobileCall::ESpeedAutobauding;

   902 	callParams.iProtocol = RMobileCall::EProtocolV32;

   903 	callParams.iQoS = RMobileCall::EQoSTransparent;

   904 	callParams.iRLPVersion = RMobileCall::ERLPNotRequested;

   905 	callParams.iModemToMSWindowSize = 100;

   906 	callParams.iMSToModemWindowSize = 100;

   907 	callParams.iAckTimer = 100;

   908 	callParams.iRetransmissionAttempts = 3;

   909 	callParams.iResequencingPeriod = 100;

   910 	callParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   911 	callParams.iV42bisCodewordsNum = 2;

   912 	callParams.iV42bisMaxStringLength = 64;

   913 	callParams.iUseEdge = EFalse;

   914 	RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);

   915 

   916 	res = call.Connect(callParamsPckg);

   917 	ASSERT_EQUALS(KErrNone, res)

   918 	

   919 	// asynchronous version with RMobileCall::TMobileHscsdCallParamsV1Pckg parameter

   920 	RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams;

   921 	hscsdCallParams.iService = RMobileCall::EServiceDataCircuitAsync;

   922 	hscsdCallParams.iSpeed = RMobileCall::ESpeedAutobauding;

   923 	hscsdCallParams.iProtocol = RMobileCall::EProtocolV32;

   924 	hscsdCallParams.iQoS = RMobileCall::EQoSTransparent;

   925 	hscsdCallParams.iRLPVersion = RMobileCall::ERLPNotRequested;

   926 	hscsdCallParams.iModemToMSWindowSize = 100;

   927 	hscsdCallParams.iMSToModemWindowSize = 100;

   928 	hscsdCallParams.iAckTimer = 100;

   929 	hscsdCallParams.iRetransmissionAttempts = 3;

   930 	hscsdCallParams.iResequencingPeriod = 100;

   931 	hscsdCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   932 	hscsdCallParams.iV42bisCodewordsNum = 2;

   933 	hscsdCallParams.iV42bisMaxStringLength = 64;

   934 	hscsdCallParams.iUseEdge = EFalse;

   935 	hscsdCallParams.iWantedAiur = RMobileCall::EAiurBps19200;

   936 	hscsdCallParams.iWantedRxTimeSlots = 2;

   937 	hscsdCallParams.iMaxTimeSlots = 3;

   938 	hscsdCallParams.iCodings = RMobileCall::KCapsAiurCoding96;

   939 	hscsdCallParams.iAsymmetry = RMobileCall::EAsymmetryDownlink;

   940 	hscsdCallParams.iUserInitUpgrade = ETrue;

   941 	RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdCallParamsPckg(hscsdCallParams);

   942 

   943 	call.Connect(reqStatus, hscsdCallParamsPckg);

   944 	User::WaitForRequest(reqStatus);

   945 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

   946 	

   947 	//------------------------------------------------------------

   948 	// TMobileDataCallParamsV2

   949 	RMobileCall::TMobileDataCallParamsV2 dataCallParams2;

   950 	dataCallParams2.iService = RMobileCall::EServiceDataCircuitAsync;

   951 	dataCallParams2.iSpeed = RMobileCall::ESpeedAutobauding;

   952 	dataCallParams2.iProtocol = RMobileCall::EProtocolV32;

   953 	dataCallParams2.iQoS = RMobileCall::EQoSTransparent;

   954 	dataCallParams2.iRLPVersion = RMobileCall::ERLPNotRequested;

   955 	dataCallParams2.iModemToMSWindowSize = 100;

   956 	dataCallParams2.iMSToModemWindowSize = 100;

   957 	dataCallParams2.iAckTimer = 100;

   958 	dataCallParams2.iRetransmissionAttempts = 3;

   959 	dataCallParams2.iResequencingPeriod = 100;

   960 	dataCallParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   961 	dataCallParams2.iV42bisCodewordsNum = 2;

   962 	dataCallParams2.iV42bisMaxStringLength = 64;

   963 	dataCallParams2.iUseEdge = EFalse;

   964 	dataCallParams2.iBearerMode = RMobileCall::EMulticallShareBearer;

   965 	RMobileCall::TMobileDataCallParamsV2Pckg dataCallParamsPckg2(dataCallParams2);

   966 

   967 	res = call.Connect(dataCallParamsPckg2);

   968 	ASSERT_EQUALS(KErrNone, res)

   969 		

   970 	//------------------------------------------------------------

   971 	// TMobileDataCallParamsV8

   972 	

   973 	RMobileCall::TMobileDataCallParamsV8 dataCallParams8;

   974 	dataCallParams8.iService = RMobileCall::EServiceDataCircuitAsync;

   975 	dataCallParams8.iSpeed = RMobileCall::ESpeedAutobauding;

   976 	dataCallParams8.iProtocol = RMobileCall::EProtocolV32;

   977 	dataCallParams8.iQoS = RMobileCall::EQoSTransparent;

   978 	dataCallParams8.iRLPVersion = RMobileCall::ERLPNotRequested;

   979 	dataCallParams8.iModemToMSWindowSize = 100;

   980 	dataCallParams8.iMSToModemWindowSize = 100;

   981 	dataCallParams8.iAckTimer = 100;

   982 	dataCallParams8.iRetransmissionAttempts = 3;

   983 	dataCallParams8.iResequencingPeriod = 100;

   984 	dataCallParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   985 	dataCallParams8.iV42bisCodewordsNum = 2;

   986 	dataCallParams8.iV42bisMaxStringLength = 64;

   987 	dataCallParams8.iUseEdge = EFalse;

   988 	dataCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer;

   989 	RMobileCall::TMobileDataCallParamsV8Pckg dataCallParamsPckg8(dataCallParams8);

   990 

   991 	res = call.Connect(dataCallParamsPckg8);

   992 	ASSERT_EQUALS(KErrNone, res)

   993 

   994 	//------------------------------------------------------------

   995 	// TMobileHscsdCallParamsV2

   996 	

   997 	RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2;

   998 	hscsdCallParams2.iService = RMobileCall::EServiceDataCircuitAsync;

   999 	hscsdCallParams2.iSpeed = RMobileCall::ESpeedAutobauding;

  1000 	hscsdCallParams2.iProtocol = RMobileCall::EProtocolV32;

  1001 	hscsdCallParams2.iQoS = RMobileCall::EQoSTransparent;

  1002 	hscsdCallParams2.iRLPVersion = RMobileCall::ERLPNotRequested;

  1003 	hscsdCallParams2.iModemToMSWindowSize = 100;

  1004 	hscsdCallParams2.iMSToModemWindowSize = 100;

  1005 	hscsdCallParams2.iAckTimer = 100;

  1006 	hscsdCallParams2.iRetransmissionAttempts = 3;

  1007 	hscsdCallParams2.iResequencingPeriod = 100;

  1008 	hscsdCallParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

  1009 	hscsdCallParams2.iV42bisCodewordsNum = 2;

  1010 	hscsdCallParams2.iV42bisMaxStringLength = 64;

  1011 	hscsdCallParams2.iUseEdge = EFalse;

  1012 	hscsdCallParams2.iWantedAiur = RMobileCall::EAiurBps19200;

  1013 	hscsdCallParams2.iWantedRxTimeSlots = 2;

  1014 	hscsdCallParams2.iMaxTimeSlots = 3;

  1015 	hscsdCallParams2.iCodings = RMobileCall::KCapsAiurCoding96;

  1016 	hscsdCallParams2.iAsymmetry = RMobileCall::EAsymmetryDownlink;

  1017 	hscsdCallParams2.iUserInitUpgrade = ETrue;

  1018 	RMobileCall::TMobileHscsdCallParamsV2Pckg hscsdCallParamsPckg2(hscsdCallParams2);

  1019 

  1020 	call.Connect(reqStatus, hscsdCallParamsPckg2);

  1021 	User::WaitForRequest(reqStatus);

  1022 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

  1023 	

  1024 	//------------------------------------------------------------

  1025 	// TMobileHscsdCallParamsV2

  1026 	

  1027 	RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7;

  1028 	hscsdCallParams7.iService = RMobileCall::EServiceDataCircuitAsync;

  1029 	hscsdCallParams7.iSpeed = RMobileCall::ESpeedAutobauding;

  1030 	hscsdCallParams7.iProtocol = RMobileCall::EProtocolV32;

  1031 	hscsdCallParams7.iQoS = RMobileCall::EQoSTransparent;

  1032 	hscsdCallParams7.iRLPVersion = RMobileCall::ERLPNotRequested;

  1033 	hscsdCallParams7.iModemToMSWindowSize = 100;

  1034 	hscsdCallParams7.iMSToModemWindowSize = 100;

  1035 	hscsdCallParams7.iAckTimer = 100;

  1036 	hscsdCallParams7.iRetransmissionAttempts = 3;

  1037 	hscsdCallParams7.iResequencingPeriod = 100;

  1038 	hscsdCallParams7.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

  1039 	hscsdCallParams7.iV42bisCodewordsNum = 2;

  1040 	hscsdCallParams7.iV42bisMaxStringLength = 64;

  1041 	hscsdCallParams7.iUseEdge = EFalse;

  1042 	hscsdCallParams7.iWantedAiur = RMobileCall::EAiurBps19200;

  1043 	hscsdCallParams7.iWantedRxTimeSlots = 2;

  1044 	hscsdCallParams7.iMaxTimeSlots = 3;

  1045 	hscsdCallParams7.iCodings = RMobileCall::KCapsAiurCoding96;

  1046 	hscsdCallParams7.iAsymmetry = RMobileCall::EAsymmetryDownlink;

  1047 	hscsdCallParams7.iUserInitUpgrade = ETrue;

  1048 	RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdCallParamsPckg7(hscsdCallParams7);

  1049 

  1050 	call.Connect(reqStatus, hscsdCallParamsPckg7);

  1051 	User::WaitForRequest(reqStatus);

  1052 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

  1053 	

  1054 	//------------------------------------------------------------

  1055 	// TMobileHscsdCallParamsV8

  1056 	

  1057 	RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8;

  1058 	hscsdCallParams8.iService = RMobileCall::EServiceDataCircuitAsync;

  1059 	hscsdCallParams8.iSpeed = RMobileCall::ESpeedAutobauding;

  1060 	hscsdCallParams8.iProtocol = RMobileCall::EProtocolV32;

  1061 	hscsdCallParams8.iQoS = RMobileCall::EQoSTransparent;

  1062 	hscsdCallParams8.iRLPVersion = RMobileCall::ERLPNotRequested;

  1063 	hscsdCallParams8.iModemToMSWindowSize = 100;

  1064 	hscsdCallParams8.iMSToModemWindowSize = 100;

  1065 	hscsdCallParams8.iAckTimer = 100;

  1066 	hscsdCallParams8.iRetransmissionAttempts = 3;

  1067 	hscsdCallParams8.iResequencingPeriod = 100;

  1068 	hscsdCallParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

  1069 	hscsdCallParams8.iV42bisCodewordsNum = 2;

  1070 	hscsdCallParams8.iV42bisMaxStringLength = 64;

  1071 	hscsdCallParams8.iUseEdge = EFalse;

  1072 	hscsdCallParams8.iWantedAiur = RMobileCall::EAiurBps19200;

  1073 	hscsdCallParams8.iWantedRxTimeSlots = 2;

  1074 	hscsdCallParams8.iMaxTimeSlots = 3;

  1075 	hscsdCallParams8.iCodings = RMobileCall::KCapsAiurCoding96;

  1076 	hscsdCallParams8.iAsymmetry = RMobileCall::EAsymmetryDownlink;

  1077 	hscsdCallParams8.iUserInitUpgrade = ETrue;

  1078 	RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdCallParamsPckg8(hscsdCallParams8);

  1079 

  1080 	call.Connect(reqStatus, hscsdCallParamsPckg8);

  1081 	User::WaitForRequest(reqStatus);

  1082 	ASSERT_EQUALS(KErrNone, reqStatus.Int())

  1083 	

  1084 	CleanupStack::PopAndDestroy(3, this); // call, line, this

  1085 	

  1086 	}

  1087 

  1088 /**

  1089 @SYMTestCaseID BA-CTSY-DATC-CC-0012

  1090 @SYMComponent  telephony_ctsy

  1091 @SYMTestCaseDesc Test support in CTSY for cancelling of RCall::Connect for fax calls

  1092 @SYMTestPriority High

  1093 @SYMTestActions Invokes cancelling of RCall::Connect for fax calls

  1094 @SYMTestExpectedResults Pass

  1095 @SYMTestType CT

  1096 */

  1097 void CCTsyDataCallControlFU::TestConnect0012L()

  1098 	{

  1099 

  1100 	OpenEtelServerL(EUseExtendedError);

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

  1102 	OpenPhoneL();

  1103 

  1104 	RLine line;

  1105 	RCall call;

  1106 	OpenLineLC(line, KMmTsyFaxLineName);

  1107 	OpenNewCallLC(line, call);

  1108 

  1109  	//-------------------------------------------------------------------------

  1110 	// Test cancelling of RCall::Connect (Not Supported)

  1111  	//-------------------------------------------------------------------------

  1112 

  1113 	RMobileCall::TMobileDataCallParamsV1 callParams;

  1114 	callParams.iService = RMobileCall::EServiceDataCircuitAsync;

  1115 	callParams.iSpeed = RMobileCall::ESpeedAutobauding;

  1116 	callParams.iProtocol = RMobileCall::EProtocolV32;

  1117 	callParams.iQoS = RMobileCall::EQoSTransparent;

  1118 	callParams.iRLPVersion = RMobileCall::ERLPNotRequested;

  1119 	callParams.iModemToMSWindowSize = 100;

  1120 	callParams.iMSToModemWindowSize = 100;

  1121 	callParams.iAckTimer = 100;

  1122 	callParams.iRetransmissionAttempts = 3;

  1123 	callParams.iResequencingPeriod = 100;

  1124 	callParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

  1125 	callParams.iV42bisCodewordsNum = 2;

  1126 	callParams.iV42bisMaxStringLength = 64;

  1127 	callParams.iUseEdge = EFalse;

  1128 	RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);

  1129 

  1130 	TRequestStatus reqStatus;

  1131 	call.Connect(reqStatus, callParamsPckg);

  1132 

  1133 	// Cancels connecting of a (data) call (Not Supported).

  1134 	call.ConnectCancel();

  1135