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 // Test step definitions for the DataCallControl functional unit.

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include "cctsyintegrationtestdatacallcontrol.h"

    23 #include "cctsyinidata.h"

    24 #include "tcallcontroltsytesthelper.h"

    25 

    26 _LIT8(KWriteTestData, "Some data");

    27 

    28 	

    29 CCTSYIntegrationTestDataCallControlBase::CCTSYIntegrationTestDataCallControlBase(CEtelSessionMgr& aEtelSessionMgr)

    30 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr),

    31 		iCallControlTestHelper(*this),

    32 		iNetworkTestHelper(*this)

    33 /**

    34  * Constructor

    35  */

    36 	{

    37 	}

    38 

    39 CCTSYIntegrationTestDataCallControlBase::~CCTSYIntegrationTestDataCallControlBase()

    40 /*

    41  * Destructor

    42  */

    43 	{

    44 	}

    45 	

    46 

    47 CCTSYIntegrationTestDataCallControl0001::CCTSYIntegrationTestDataCallControl0001(CEtelSessionMgr& aEtelSessionMgr)

    48 	: CCTSYIntegrationTestDataCallControlBase(aEtelSessionMgr)

    49 /**

    50  * Constructor.

    51  */

    52 	{

    53 	SetTestStepName(CCTSYIntegrationTestDataCallControl0001::GetTestStepName());

    54 	}

    55 

    56 CCTSYIntegrationTestDataCallControl0001::~CCTSYIntegrationTestDataCallControl0001()

    57 /**

    58  * Destructor.

    59  */

    60 	{

    61 	}

    62 

    63 TVerdict CCTSYIntegrationTestDataCallControl0001::doTestStepL()

    64 /**

    65  * @SYMTestCaseID BA-CTSY-INT-DATC-0001

    66  * @SYMFssID BA/CTSY/DATC-0001

    67  * @SYMTestCaseDesc Make a circuit switched data call.

    68  * @SYMTestPriority High

    69  * @SYMTestActions RCall::GetCaps, RMobileCall::GetMobileCallCaps, RCall::HangUp, RMobileCall::NotifyMobileCallCapsChange, RCall::RecoverDataPort, RMobileCall::GetMobileCallStatus, RCall::GetCallParams, RMobileCall::GetMobileCallInfo, RCall::GetInfo, RCall::NotifyStatusChange, RMobileCall::NotifyMobileCallStatusChange, RCall::NotifyHookChange, RCall::NotifyCapsChange, RCall::LoanDataPort, RCall::GetStatus

    70  * @SYMTestExpectedResults Pass - Data call can be made. Data can be sent.

    71  * @SYMTestType CIT

    72  * @SYMTestCaseDependencies live/automatic

    73  *

    74  * Reason for test: Verify call status, call caps and call info are correct.

    75  *

    76  * @return - TVerdict code

    77  */

    78 	{

    79 

    80 	//

    81 	// SET UP

    82 	//

    83 

    84 	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer,KMainPhone);

    85  	

    86  	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone,

    87 				   _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

    88 		

    89 	// Ensure phone supports KCapsData caps. 

    90 	RMobilePhone::TCaps mobilephonecaps;

    91 	CHECK_EQUALS_L(phone.GetCaps(mobilephonecaps), KErrNone, _L("RMobilePhone::GetCaps"));

    92 	TUint32 expectedmobilephoneCaps = RMobilePhone::KCapsData | RMobilePhone::KCapsVoice;

    93 	TUint32 unwantedmobilephoneCaps = KNoUnwantedBits;

    94 	CHECK_BITS_SET_L(mobilephonecaps.iFlags, expectedmobilephoneCaps, unwantedmobilephoneCaps,

    95 					_L("RMobilePhone::GetCaps returned wrong dynamic caps"));

    96 	

    97 	// Get data line 1. 

    98 	RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KDataLine);

    99 

   100 	// Get Call 1.

   101 	RMobileCall& call1= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KDataLine, KCall1);

   102 

   103 	//

   104 	// SET UP END

   105 	//

   106 	

   107 	StartTest();

   108 	

   109 	//

   110 	// TEST START

   111 	//

   112 	

   113 	

   114 	// ===  Check call caps ===

   115 

   116 	// Check RCall::GetCaps supports KCapsDial | KCapsData.

   117 	RCall::TCaps callCaps;

   118 	TUint32 wantedCallCaps = RCall::KCapsDial | RCall::KCapsData;

   119 	ASSERT_EQUALS(call1.GetCaps(callCaps),KErrNone, _L("RCall::GetCaps returned an error"));

   120 	ASSERT_BITS_SET(callCaps.iFlags, wantedCallCaps, KNoUnwantedBits, _L("RCall::GetCaps returned wrong caps"));

   121 

   122 	// Check RMobileCall::GetMobileCallCaps returns iCallControlCaps in set of KCapsData | KCapsDial.

   123 	TUint32 wantedCallControlCaps = RMobileCall::KCapsData | RMobileCall::KCapsDial;

   124 	TUint32 wantedCallEventCaps = 0;

   125 	RMobileCall::TMobileCallCapsV1 mobileCallCaps;

   126 	RMobileCall::TMobileCallCapsV1Pckg mobileCallCapsPckg(mobileCallCaps);

   127 	ASSERT_EQUALS(call1.GetMobileCallCaps(mobileCallCapsPckg), KErrNone, _L("RMobileCall::GetMobileCallCaps returned an error"));

   128 	ASSERT_BITS_SET(mobileCallCaps.iCallControlCaps, wantedCallControlCaps, KNoUnwantedBits,   

   129                     _L("RMobileCall::GetMobileCallCaps returned wrong caps"));

   130 

   131 	// Check RMobileCall::GetMobileCallCaps includes iCallEventCaps in set of 0.

   132 	ASSERT_BITS_SET(mobileCallCaps.iCallEventCaps, wantedCallEventCaps, KNoUnwantedBits,

   133 			      _L("RMobileCall::GetMobileCallCaps returned unexpected iCallEventCaps"));

   134 

   135 	// ===  Check call status ===

   136 

   137 	// Check RCall::GetStatus returns EStatusIdle.

   138 	RCall::TStatus callStatus;

   139 	ASSERT_EQUALS(call1.GetStatus(callStatus), KErrNone, _L("RCall::GetStatus returned an Error"));

   140 	ASSERT_EQUALS(callStatus, RCall::EStatusIdle, _L("RCall::GetStatus did not return EStatusIdle"));

   141 

   142 	// Check RMobileCall::GetMobileCallStatus returns status of EStatusIdle.

   143 	RMobileCall::TMobileCallStatus mobileCallStatus;

   144 	ASSERT_EQUALS(call1.GetMobileCallStatus(mobileCallStatus), KErrNone,    

   145 			_L("RMobileCall::GetMobileCallStatus returned an Error"));

   146 	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusIdle,    

   147 			_L("RMobileCall::GetMobileCallStatus did not set the status to EStatusIdle"));

   148 

   149 	// ===  Check call info ===

   150 

   151 	// Check RCall::GetInfo returns valid call name.

   152 	RCall::TCallInfo callInfo;

   153 	ASSERT_EQUALS(call1.GetInfo(callInfo), KErrNone, _L("RCall::GetInfo returned an error"));

   154 	ASSERT_TRUE(callInfo.iCallName.Length() > 0, _L("RCall::GetInfo returned an invalid call name"));

   155 	

   156 	// Check RCall::GetInfo returns valid data line name.

   157 	ASSERT_TRUE(callInfo.iLineName.Length() > 0,_L("RCall::GetInfo returned an invalid  line name"));

   158 	

   159 	// Check RCall::GetInfo returns hook status of EHookStatusOn.

   160 	// $CTSYProblem CMmCallTsy::GetInfo() returns EHookStatusUnknown always,

   161 	// it is hard coded (aCallInfo->iHookStatus = RCall::EHookStatusUnknown;)

   162 	ASSERT_EQUALS(callInfo.iHookStatus, RCall::EHookStatusUnknown, _L("RCall::GetInfo returned wrong status, should be EHookStatusUnknown"));

   163 

   164 	// Check RCall::GetInfo returns call status of EStatusIdle.

   165 	ASSERT_EQUALS(callInfo.iStatus, RCall::EStatusIdle, _L("RCall::GetInfo returned wrong status, should be EStatusIdle"));

   166 

   167 	// Check RCall::GetInfo returns call duration of 0.

   168 	ASSERT_EQUALS(callInfo.iDuration.Int(), 0, _L("RCall::GetInfo returned duration > 0, should be 0"));

   169 

   170 	// Check RMobileCall::GetMobileCallInfo returns iValid > 0.

   171 	RMobileCall::TMobileCallInfoV1 mobileCallInfo;

   172 	RMobileCall::TMobileCallInfoV1Pckg mobileCallInfoPckg(mobileCallInfo);

   173 	ASSERT_EQUALS(call1.GetMobileCallInfo(mobileCallInfoPckg), KErrNone, _L("RMobileCall::GetMobileCallInfo returned an error"));

   174 	ASSERT_TRUE(mobileCallInfo.iValid > 0, _L("RMobileCall::GetMobileCallInfo returned iValid <= 0 flags, should be > 0"));

   175 	

   176 	// Check RMobileCall::GetMobileCallInfo returns valid call name.

   177 	ASSERT_TRUE(mobileCallInfo.iCallName.Length() > 0, _L("RMobileCall::GetMobileCallInfo returned an invalid call name"));

   178 

   179 	// Check RMobileCall::GetMobileCallInfo returns valid line name.

   180 	ASSERT_TRUE(mobileCallInfo.iLineName.Length() > 0, _L("RMobileCall::GetMobileCallInfo returned an invalid line name"));

   181 

   182 	// post notifier for RCall::NotifyStatusChange

   183 	TCoreEtelRequestStatus<RCall> notifyStatusChangeStatus (call1, &RCall::NotifyStatusChangeCancel);

   184 	CleanupStack::PushL(notifyStatusChangeStatus);

   185 	RCall::TStatus notifyCallStatus;

   186 	call1.NotifyStatusChange(notifyStatusChangeStatus, notifyCallStatus);

   187 

   188 	// Post notifiers RMobileCall::NotifyMobileCallStatusChange

   189     RMobileCall::TMobileCallStatus notifyMobileCallStatus;

   190     TExtEtelRequestStatus notifyMobileCallChangeStatus(call1, EMobileCallNotifyMobileCallStatusChange);

   191     CleanupStack::PushL(notifyMobileCallChangeStatus);

   192     call1.NotifyMobileCallStatusChange(notifyMobileCallChangeStatus, notifyMobileCallStatus);

   193 

   194 	// Post Notifier for RCall::NotifyCapsChange

   195 	TCoreEtelRequestStatus<RCall> notifyCapsChangeStatus (call1,&RCall::NotifyCapsChangeCancel);	

   196 	CleanupStack::PushL(notifyCapsChangeStatus);

   197 	RCall::TCaps caps;

   198 	call1.NotifyCapsChange(notifyCapsChangeStatus,caps);	

   199 

   200 	// post a notifier for RMobileCall::NotifyMobileCallCapsChange

   201 	TExtEtelRequestStatus notifyMobileCallCapsChangeStatus(call1, EMobileCallNotifyMobileCallCapsChange);

   202 	CleanupStack::PushL(notifyMobileCallCapsChangeStatus);

   203 	call1.NotifyMobileCallCapsChange(notifyMobileCallCapsChangeStatus, mobileCallCapsPckg);

   204 

   205 

   206 	// post notifier for RCall::NotifyHookChange

   207 	// @CTSYProblem NotifyHookChange has never been called

   208 	TCoreEtelRequestStatus<RCall> notifyHookChangeStatus(call1, &RCall::NotifyHookChangeCancel);

   209 	CleanupStack::PushL(notifyHookChangeStatus);

   210 	RCall::THookStatus hookStatus;

   211 	call1.NotifyHookChange(notifyHookChangeStatus, hookStatus);

   212 

   213 	// Dial a number that answers. 

   214 	TPtrC number;

   215 	ASSERT_TRUE(GetStringFromConfig(KIniDataNumSection, KIniDataNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

   216 	TCoreEtelRequestStatus<RCall> dialStatus(call1, &RCall::DialCancel);

   217 	CleanupStack::PushL(dialStatus);

   218 	DisplayUserInteractionPromptL(_L("Board now dials to DataNumber1 (press any key to start dialling) "), ETimeLong);

   219 	call1.Dial(dialStatus, number);

   220     DEBUG_PRINTF2(_L("Dialling data call: %S"), &number);

   221 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeVeryLong), KErrNone, _L("RCall::Dial timed-out"));

   222 	ASSERT_EQUALS(dialStatus.Int(), KErrNone,  _L("RCall::Dial returned with an error"));

   223 

   224 	// ===  Check call status ===

   225 

   226 	// Check RCall::NotifyStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

   227 	RCall::TStatus expectedCallStatus = RCall::EStatusDialling;

   228 	const TInt wantedStatus = KErrNone;

   229 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   230 														 notifyStatusChangeStatus,

   231 														 notifyCallStatus,

   232 														 expectedCallStatus,

   233 														 wantedStatus);

   234 														 

   235 	call1.NotifyStatusChange(notifyStatusChangeStatus, notifyCallStatus);

   236 	expectedCallStatus = RCall::EStatusConnecting;

   237 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   238 														 notifyStatusChangeStatus,

   239 														 notifyCallStatus,

   240 														 expectedCallStatus,

   241 														 wantedStatus);

   242 														 

   243 	call1.NotifyStatusChange(notifyStatusChangeStatus, notifyCallStatus);

   244 	expectedCallStatus = RCall::EStatusConnected;

   245 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   246 														 notifyStatusChangeStatus,

   247 														 notifyCallStatus,

   248 														 expectedCallStatus,

   249 														 wantedStatus);

   250 

   251 	// Check RCall::GetStatus returns EStatusConnected.

   252 	ASSERT_EQUALS(call1.GetStatus(callStatus), KErrNone, _L("RCall::GetStatus returned an error"));

   253 	ASSERT_EQUALS(callStatus, RCall::EStatusConnected, _L("RCall::GetStatus did not return EStatusConnected"));

   254 

   255 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

   256 	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDialling;

   257 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   258 																		 notifyMobileCallChangeStatus,

   259 																		 notifyMobileCallStatus,

   260 																		 expectedMobileCallStatus,

   261 																	  	 wantedStatus);

   262 														 

   263 	call1.NotifyMobileCallStatusChange(notifyMobileCallChangeStatus, notifyMobileCallStatus);

   264 	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

   265     iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   266 																		 notifyMobileCallChangeStatus,

   267 																		 notifyMobileCallStatus,

   268 																		 expectedMobileCallStatus,

   269 																	  	 wantedStatus);

   270 														 

   271 	call1.NotifyMobileCallStatusChange(notifyMobileCallChangeStatus, notifyMobileCallStatus);

   272 	expectedMobileCallStatus = RMobileCall::EStatusConnected;

   273 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   274 																		 notifyMobileCallChangeStatus,

   275 																		 notifyMobileCallStatus,

   276 																		 expectedMobileCallStatus,

   277 																	  	 wantedStatus);

   278     call1.NotifyMobileCallStatusChange(notifyMobileCallChangeStatus, notifyMobileCallStatus);

   279 

   280 

   281 	// Check RMobileCall::GetMobileCallStatus returns status of EStatusConnected.

   282 	ASSERT_EQUALS(call1.GetMobileCallStatus(mobileCallStatus), KErrNone, 

   283 			_L("RMobileCall::GetMobileCallStatus returned an error"));

   284 	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusConnected, 

   285 			_L("RMobileCall::GetMobileCallStatus did not return a status EStatusConnected"));

   286 

   287 	// ===  Get call parameters ===

   288 	RMobileCall::TMobileDataCallParamsV1 checkParams;

   289 	RMobileCall::TMobileDataCallParamsV1Pckg checkParamsPkg(checkParams);

   290 	call1.GetCallParams(checkParamsPkg);

   291 	

   292 	// Check RCall::GetCallParams with aParams of type TMobileDataCallParamsV1 returns aParams.iSpeed!=RMobileCall::ESpeedUnspecified

   293 	ASSERT_TRUE(checkParams.iSpeed != RMobileCall::ESpeedUnspecified,

   294 	            _L("RCall::GetCallParams returned wrongly RMobileCall::ESpeedUnspecified"));

   295 	

   296 	// Check RCall::GetCallParams with aParams of type TMobileDataCallParamsV1 returns aParams.iService != RMobileCall::EServiceUnspecified

   297 	ASSERT_TRUE(checkParams.iService != RMobileCall::EServiceUnspecified,

   298 	            _L("RCall::GetCallParams returned wrongly RMobileCall::EServiceUnspecified"));

   299 	

   300 	// Check RCall::GetCallParams with aParams of type TMobileDataCallParamsV1 returns aParams.iProtocol != RMobileCall::EProtocolUnspecified

   301 	// @CTSYProblem RCall::GetCallParams returns EProtocolUnspecified always, it comes from LTSY in CMmCallGsmWcdmaExt::ReceivedCallParams

   302 	ASSERT_EQUALS(checkParams.iProtocol,  RMobileCall::EProtocolUnspecified,

   303 	            _L("RCall::GetCallParams returned wrongly RMobileCall::EProtocolUnspecified"));

   304 	

   305 	// ===  Check call caps ===

   306 

   307 	// Check RCall::NotifyCapsChange completes with caps in set of KCapsData | KCapsHangUp | KCapsLoanDataPort.

   308 	// Check RCall::NotifyCapsChange completes with caps NOT in set of KCapsDial | KCapsConnect

   309 	RCall::TCaps wantedCaps, unwantedCaps;

   310 	wantedCaps.iFlags = RCall::KCapsData | RCall::KCapsHangUp | RCall::KCapsLoanDataPort;

   311 	unwantedCaps.iFlags = RCall::KCapsDial | RCall::KCapsConnect;

   312 	iCallControlTestHelper.WaitForCallNotifyCapsChange(call1,

   313 													   notifyCapsChangeStatus,

   314 													   caps,

   315 													   wantedCaps,

   316 													   unwantedCaps,

   317 													   wantedStatus);

   318 

   319 	// Check RCall::GetCaps supports caps in set of KCapsHangUp | KCapsData | KCapsLoanDataPort.

   320 	// Check RCall::GetCaps supports caps NOT in set of KCapsDial | KCapsConnect

   321 	ASSERT_EQUALS(call1.GetCaps(caps), KErrNone, _L("RCall::GetCaps returned an Error"));

   322 	wantedCaps.iFlags = RCall::KCapsHangUp | RCall::KCapsData | RCall::KCapsLoanDataPort;

   323 	unwantedCaps.iFlags = RCall::KCapsDial | RCall::KCapsConnect;

   324 	ASSERT_BITS_SET(caps.iFlags,

   325 					wantedCaps.iFlags,

   326 					unwantedCaps.iFlags,

   327 			        _L("RCall::GetCaps returned wrong caps"));

   328 

   329 	// Check RMobileCall::NotifyMobileCallCapsChange completes with iCallControlCaps in set of KCapsData | KCapsHangUp | KCapsTransfer | KCapsLoanDataPort

   330 	// Check RMobileCall::NotifyMobileCallCapsChange completes with iCallControlCaps NOT in set of KCapsDial | KCapsConnect

   331 	// Check RMobileCall::NotifyMobileCallCapsChange completes with iCallEventCaps in set of KCapsLocalTransfer | KCapsRemoteTerminate

   332 	RMobileCall::TMobileCallCapsV1 wantedMobileCaps;

   333 	RMobileCall::TMobileCallCapsV1 unwantedMobileCaps;

   334     // @CTSYProblem No KCapsTransfer is sent. 

   335 	wantedMobileCaps.iCallControlCaps = RMobileCall::KCapsData | RMobileCall::KCapsHangUp | RMobileCall::KCapsLoanDataPort /* | RMobileCall::KCapsTransfer */;

   336 	unwantedMobileCaps.iCallControlCaps = RMobileCall::KCapsDial | RMobileCall::KCapsConnect;

   337 	wantedMobileCaps.iCallEventCaps = RMobileCall::KCapsLocalTransfer | RMobileCall::KCapsRemoteTerminate;

   338 	TCmpRMobileCallTMobileCallCaps mobileCapsComp(wantedMobileCaps, mobileCallCaps, *this);

   339 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallCapsChange(call1,

   340 																	   notifyMobileCallCapsChangeStatus,

   341 																	   mobileCapsComp,

   342 																	   wantedStatus);

   343 	call1.NotifyMobileCallCapsChange(notifyMobileCallCapsChangeStatus, mobileCallCapsPckg);

   344 

   345 	// Check RMobileCall::GetMobileCallCaps includes iCallControlCaps in set of KCapsData | KCapsHangUp | KCapsTransfer | KCapsLoanDataPort

   346 	// Check RMobileCall::GetMobileCallCaps includes iCallControlCaps NOT in set of KCapsDial | KCapsConnect

   347 	ASSERT_EQUALS(call1.GetMobileCallCaps(mobileCallCapsPckg), KErrNone,  

   348 			      _L("RMobileCall::GetMobileCallCaps returned an error"));

   349     // @CTSYProblem No KCapsTransfer is set. 

   350 	wantedMobileCaps.iCallControlCaps = RMobileCall::KCapsData | RMobileCall::KCapsHangUp | RMobileCall::KCapsLoanDataPort /* | RMobileCall::KCapsTransfer */;

   351 	unwantedMobileCaps.iCallControlCaps = RMobileCall::KCapsDial | RMobileCall::KCapsConnect;

   352 	ASSERT_BITS_SET(mobileCallCaps.iCallControlCaps,

   353                     wantedMobileCaps.iCallControlCaps,

   354                     unwantedMobileCaps.iCallControlCaps,

   355                     _L("RMobileCall::GetMobileCallCaps returned unexpected iCallControlCaps"));

   356 

   357 	// Check RMobileCall::GetMobileCallCaps includes iCallEventCaps in set of KCapsLocalTransfer | KCapsRemoteTerminate

   358 	wantedMobileCaps.iCallEventCaps = RMobileCall::KCapsLocalTransfer | RMobileCall::KCapsRemoteTerminate;

   359     ASSERT_BITS_SET(mobileCallCaps.iCallEventCaps, wantedMobileCaps.iCallEventCaps,

   360                     KNoUnwantedBits, 

   361                     _L("RMobileCall::GetMobileCallCaps returned unexpected iCallEventCaps"));

   362 	

   363 	// ===  Check call info ===

   364 

   365 	// Check RCall::GetInfo returns valid call name.

   366 	ASSERT_EQUALS(call1.GetInfo(callInfo), KErrNone, _L("RCall::GetInfo returned an error"));

   367 	ASSERT_TRUE(callInfo.iCallName.Length() > 0, _L("RCall::GetInfo returned an invalid call name"));

   368 	

   369 	// Check RCall::GetInfo returns valid voice line name.

   370 	ASSERT_TRUE(callInfo.iLineName.Length() > 0,_L("RCall::GetInfo returned an invalid  line name"));

   371 	

   372 	// Check RCall::GetInfo returns hook status of EHookStatusOff.

   373 	// $CTSYProblem CMmCallTsy::GetInfo() returns EHookStatusUnknown always,

   374 	// it is hard coded (aCallInfo->iHookStatus = RCall::EHookStatusUnknown;)

   375 	ASSERT_EQUALS(callInfo.iHookStatus, RCall::EHookStatusUnknown, _L("RCall::GetInfo returned wrong status, should be EHookStatusUnknown"));

   376 	

   377 	// Check RCall::GetInfo returns call status of EStatusConnected.

   378 	ASSERT_EQUALS(callInfo.iStatus, RCall::EStatusConnected, _L("RCall::GetInfo returned wrong status, should be EStatusConnected"));

   379 

   380 	// Check RCall::GetInfo returns call duration of > 0.

   381 	ASSERT_TRUE(callInfo.iDuration.Int() > 0, _L("RCall::GetInfo returned duration <= 0, should be > 0"));

   382 

   383 	// Check RMobileCall::GetMobileCallInfo returns iValid > 0.

   384 	// Check RMobileCall::GetMobileCallInfo returns data for attributes makred as valid in iValid.

   385 	// Check RMobileCall::GetMobileCallInfo returns valid line name.

   386 	ASSERT_EQUALS(call1.GetMobileCallInfo(mobileCallInfoPckg), KErrNone,  

   387 				  _L("RMobileCall::GetMobileCallInfo returned an error"));

   388 	ASSERT_TRUE(mobileCallInfo.iLineName.Length() > 0,  

   389 				_L("RMobileCall::GetMobileCallInfo returned an invalid line name"));

   390 	ASSERT_TRUE(mobileCallInfo.iValid > 0,  

   391 				_L("RMobileCall::GetMobileCallInfo returned unexpected flags in iValid"));

   392 	

   393 	iCallControlTestHelper.CheckForValidCallInfo(mobileCallInfo);

   394 

   395 	// ===  Check hook status ===

   396 

   397 	// Check RCall::NotifyHookChange completes with EHookStatusOff.

   398 	// $CTSYProblem adaptation does not support RCall::NotifyHookChange, it gives status -5 (KErrNotSupported).

   399 	RCall::THookStatus expectedHookStatus = RCall::EHookStatusOff;

   400 	iCallControlTestHelper.WaitForCallNotifyHookChange(call1,

   401 													notifyHookChangeStatus,

   402 													hookStatus, 

   403 													expectedHookStatus,

   404 													wantedStatus);

   405 

   406 	// ===  Loan data port ===

   407 

   408 	// Declare a RCall::TCommPort 

   409 	RCall::TCommPort commPort;

   410 

   411 	// Loan the data port with RCall::LoanDataPort passing in the TCommPort 

   412 	ASSERT_EQUALS(call1.LoanDataPort(commPort), KErrNone,  

   413 				  _L("RCall::LoanDataPort returned an error"));

   414 

   415 	// ===  Check call caps ===

   416 

   417 	// Check RCall::NotifyCapsChange completes with caps in set of KCapsData | KCapsHangUp | KCapsRecoverDataPort.

   418 	// Check RCall::NotifyCapsChange completes with caps NOT in set of KCapsDial | KCapsConnect

   419 	wantedCaps.iFlags = RCall::KCapsData | RCall::KCapsHangUp | RCall::KCapsRecoverDataPort;

   420 	unwantedCaps.iFlags = RCall::KCapsDial | RCall::KCapsConnect;

   421 	iCallControlTestHelper.WaitForCallNotifyCapsChange(call1,

   422 													   notifyCapsChangeStatus,

   423 													   caps,

   424 													   wantedCaps,

   425 													   unwantedCaps,

   426 													   wantedStatus);

   427 

   428 	// Check RCall::GetCaps supports caps in set of KCapsHangUp | KCapsData | KCapsRemoteTerminate.

   429 	// Check RCall::GetCaps supports caps NOT in set of KCapsDial | KCapsConnect

   430     // @CTSYProblem KCapsRemoteTerminate is not set

   431 	ASSERT_EQUALS(call1.GetCaps(caps), KErrNone, _L("RCall::GetCaps returned an Error"));

   432 	wantedCaps.iFlags = RCall::KCapsHangUp | RCall::KCapsData /* | RMobileCall::KCapsRemoteTerminate */;

   433 	unwantedCaps.iFlags = RCall::KCapsDial | RCall::KCapsConnect;

   434 	ASSERT_BITS_SET(caps.iFlags,

   435 					wantedCaps.iFlags,

   436 					unwantedCaps.iFlags,

   437 			        _L("RCall::GetCaps returned wrong caps"));

   438 

   439 

   440 	// Check RMobileCall::GetMobileCallCaps includes iCallControlCaps in set of KCapsData | KCapsHangUp | KCapsTransfer | KCapsRemoteTerminate

   441 	// Check RMobileCall::GetMobileCallCaps includes iCallControlCaps NOT in set of KCapsDial | KCapsConnect

   442 	ASSERT_EQUALS(call1.GetMobileCallCaps(mobileCallCapsPckg), KErrNone,  

   443 			      _L("RMobileCall::GetMobileCallCaps returned an error"));

   444 	wantedCaps.iFlags = RMobileCall::KCapsData | RMobileCall::KCapsHangUp;

   445 	unwantedCaps.iFlags = RMobileCall::KCapsDial | RMobileCall::KCapsConnect;

   446 	ASSERT_BITS_SET(mobileCallCaps.iCallControlCaps,

   447 					wantedCaps.iFlags,

   448 					unwantedCaps.iFlags,

   449 					_L("RMobileCall::GetMobileCallCaps returned unexpected iCallControlCaps"));

   450 

   451 	// Check RMobileCall::GetMobileCallCaps includes iCallEventCaps in set of KCapsLocalTransfer | KCapsRemoteTerminate

   452 	wantedCaps.iFlags = RMobileCall::KCapsLocalTransfer | RMobileCall::KCapsRemoteTerminate;

   453 	ASSERT_BITS_SET(mobileCallCaps.iCallEventCaps, wantedCaps.iFlags,

   454                     KNoUnwantedBits,

   455                     _L("RMobileCall::GetMobileCallCaps returned unexpected iCallEventCaps"));

   456 

   457 	// ===  Write some data to the port ===

   458 

   459 	// RCommServ cs; 

   460 	RCommServ cs;

   461 

   462 	// cs.Connect(); 

   463 	ASSERT_EQUALS(cs.Connect(), KErrNone,  _L("RRCommServ::Connect returned an error"));

   464 

   465 	// RComm port; 

   466 	RComm port;

   467 	

   468 	// port.Open(cs,commPort.iPort,ECommShared); 

   469 	port.Open(cs, commPort.iPort, ECommShared);

   470 	

   471 	// port.Write(stat,KWriteTestData);

   472 	TRequestStatus writeStatus;

   473 	port.Write(writeStatus, KWriteTestData); 

   474 

   475 	// port.Close();

   476 	port.Close();

   477 

   478 	// cs.Close();

   479 	cs.Close();

   480 

   481 	// ===  Recover the data port ===

   482 

   483 	// Recover data port with RCall::RecoverDataPort 

   484 	ASSERT_EQUALS(call1.RecoverDataPort(), KErrNone, _L("RMobileCall::RecoverDataPort() returned an error"));

   485 

   486 	// Hang up with RCall::HangUp 

   487 	TCoreEtelRequestStatus<RCall> hangUpStatus (call1, &RCall::HangUpCancel);	

   488 	CleanupStack::PushL(hangUpStatus);

   489 	call1.HangUp(hangUpStatus);

   490 	ASSERT_EQUALS(WaitForRequestWithTimeOut(hangUpStatus, ETimeLong), KErrNone, _L("RCall::HangUp timed-out"));

   491 	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RCall::HangUp returned an error"));	

   492 

   493 	// ===  Check call caps ===

   494 

   495 	// Check RCall::NotifyCapsChange completes with caps in set of KCapsData | KCapsDial.

   496 	wantedCaps.iFlags = RCall::KCapsData | RCall::KCapsDial;

   497 	unwantedCaps.iFlags = 0;	

   498 	iCallControlTestHelper.WaitForCallNotifyCapsChange(call1,

   499 													   notifyCapsChangeStatus,

   500 													   caps,

   501 													   wantedCaps,

   502 													   unwantedCaps,

   503 													   wantedStatus);

   504 

   505 	// Check RCall::GetCaps supports KCapsData | KCapsHangUp.

   506 	// @CTSYProblem KCapsHangUp is not set

   507 	ASSERT_EQUALS(call1.GetCaps(caps), KErrNone, _L("RCall::GetCaps returned an Error"));

   508     wantedCaps.iFlags = RCall::KCapsData;

   509 	ASSERT_BITS_SET(caps.iFlags, wantedCaps.iFlags, KNoUnwantedBits,

   510 			        _L("RCall::GetCaps returned wrong caps"));

   511 

   512 	// Check RMobileCall::NotifyMobileCallCapsChange completes with iCallControlCaps in set of KCapsData | KCapsDial.

   513 	// Check RMobileCall::NotifyMobileCallCapsChange completes with iCallEventCaps in set of 0.

   514     // @CTSYProblem NotifyMobileCallCapsChange is not called

   515 

   516 	// Check RMobileCall::GetMobileCallCaps includes iCallControlCaps in set of KCapsData | KCapsDial.

   517 	ASSERT_EQUALS(call1.GetMobileCallCaps(mobileCallCapsPckg), KErrNone,  

   518 			      _L("RMobileCall::GetMobileCallCaps returned an error"));

   519     wantedMobileCaps.iCallControlCaps = RMobileCall::KCapsDial | RMobileCall::KCapsData;

   520 	ASSERT_BITS_SET(mobileCallCaps.iCallControlCaps, wantedMobileCaps.iCallControlCaps, KNoUnwantedBits,

   521 			      _L("RMobileCall::GetMobileCallCaps returned unexpected iCallControlCaps"));

   522 

   523 	// Check RMobileCall::GetMobileCallCaps includes iCallEventCaps in set of 0.

   524 	wantedMobileCaps.iCallEventCaps = 0;

   525 	ASSERT_BITS_SET(mobileCallCaps.iCallEventCaps, 0, KNoUnwantedBits,

   526 			      _L("RMobileCall::GetMobileCallCaps returned unexpected iCallEventCaps"));

   527 

   528 	// ===  Check call status ===

   529 

   530 	// Check RCall::NotifyStatusChange completes with EStatusHangingUp -> EStatusIdle.

   531 	expectedCallStatus = RCall::EStatusHangingUp;

   532 	call1.NotifyStatusChange(notifyStatusChangeStatus, notifyCallStatus);

   533 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   534 														 notifyStatusChangeStatus,

   535 														 notifyCallStatus,

   536 														 expectedCallStatus,

   537 														 wantedStatus);

   538 														 

   539 	call1.NotifyStatusChange(notifyStatusChangeStatus, notifyCallStatus);

   540 	expectedCallStatus = RCall::EStatusIdle;

   541 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   542 														 notifyStatusChangeStatus,

   543 														 notifyCallStatus,

   544 														 expectedCallStatus,

   545 														 wantedStatus);

   546 														 

   547 

   548 	// Check RCall::GetStatus returns EStatusIdle.

   549 	ASSERT_EQUALS(call1.GetStatus(callStatus), KErrNone, _L("RCall::GetStatus returned an error"));

   550 	ASSERT_EQUALS(callStatus, RCall::EStatusIdle, _L("RCall::GetStatus did not return EStatusIdle"));

   551 

   552 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDisconnecting -> EStatusIdle.

   553 	expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

   554 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   555 																		 notifyMobileCallChangeStatus,

   556 																		 notifyMobileCallStatus,

   557 																		 expectedMobileCallStatus,

   558 																	  	 wantedStatus);

   559 

   560 	call1.NotifyMobileCallStatusChange(notifyMobileCallChangeStatus, notifyMobileCallStatus);

   561 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   562     iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   563 																		 notifyMobileCallChangeStatus,

   564 																		 notifyMobileCallStatus,

   565 																		 expectedMobileCallStatus,

   566 																	  	 wantedStatus);

   567 

   568 	// Check RMobileCall::GetMobileCallStatus returns status of EStatusIdle.

   569 	ASSERT_EQUALS(call1.GetMobileCallStatus(mobileCallStatus), KErrNone, 

   570 			_L("RMobileCall::GetMobileCallStatus returned an error"));

   571 	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusIdle, 

   572 			_L("RMobileCall::GetMobileCallStatus did not return a status EStatusIdle"));

   573 

   574 	// ===  Check call info ===

   575 

   576 	// Check RCall::GetInfo returns valid call name.

   577 	ASSERT_EQUALS(call1.GetInfo(callInfo), KErrNone, _L("RCall::GetInfo returned an error"));

   578 	ASSERT_TRUE(callInfo.iCallName.Length() > 0, _L("RCall::GetInfo returned an invalid call name"));

   579 

   580 	// Check RCall::GetInfo returns valid voice line name.

   581 	ASSERT_TRUE(callInfo.iLineName.Length() > 0,_L("RCall::GetInfo returned an invalid  line name"));

   582 

   583 	// Check RCall::GetInfo returns hook status of EHookStatusOn.

   584 	// $CTSYProblem CMmCallTsy::GetInfo() returns EHookStatusUnknown always,

   585 	// it is hard coded (aCallInfo->iHookStatus = RCall::EHookStatusUnknown;)

   586 	ASSERT_EQUALS(callInfo.iHookStatus, RCall::EHookStatusUnknown, _L("RCall::GetInfo returned wrong status, should be EHookStatusUnknown"));

   587 

   588 	// Check RCall::GetInfo returns call status of EStatusIdle.

   589 	ASSERT_EQUALS(callInfo.iStatus, RCall::EStatusIdle, _L("RCall::GetInfo returned wrong status, should be EStatusIdle"));

   590 

   591 	// Check RCall::GetInfo returns call duration of > 0.

   592 	ASSERT_TRUE(callInfo.iDuration.Int() > 0, _L("RCall::GetInfo returned duration <= 0, should be > 0"));

   593 

   594 	// Check RMobileCall::GetMobileCallInfo returns iValid > 0.

   595 	// Check RMobileCall::GetMobileCallInfo returns data for attributes makred as valid in iValid.

   596 	// Check RMobileCall::GetMobileCallInfo returns valid line name.

   597 	ASSERT_EQUALS(call1.GetMobileCallInfo(mobileCallInfoPckg), KErrNone,  

   598 				  _L("RMobileCall::GetMobileCallInfo returned an error"));

   599 	ASSERT_TRUE(mobileCallInfo.iLineName.Length() > 0,  

   600 				_L("RMobileCall::GetMobileCallInfo returned an invalid line name"));

   601 	ASSERT_TRUE(mobileCallInfo.iValid > 0,  

   602 				_L("RMobileCall::GetMobileCallInfo returned unexpected flags in iValid"));

   603 

   604 	// ===  Check hook status ===

   605 

   606 	// Check RCall::NotifyHookChange completes with EHookStatusOn.

   607 	// $CTSYProblem adaptation does not support RCall::NotifyHookChange, it gives status -5 (KErrNotSupported).

   608 	expectedHookStatus = RCall::EHookStatusOn;

   609 	iCallControlTestHelper.WaitForCallNotifyHookChange(call1,

   610 													notifyHookChangeStatus,

   611 													hookStatus, 

   612 													expectedHookStatus,

   613 													wantedStatus);

   614 

   615 	

   616 	//

   617 	// TEST END

   618 	//

   619 

   620     StartCleanup();

   621 	

   622 	// Pop

   623 	// notifyStatusChangeStatus

   624 	// notifyMobileCallChangeStatus

   625 	// notifyCapsChangeStatus

   626 	// notifyMobileCallCapsChangeStatus

   627 	// notifyHookChangeStatus

   628 	// dialStatus

   629 	// hangUpStatus

   630 	CleanupStack::PopAndDestroy(7, &notifyStatusChangeStatus);

   631 

   632 	

   633 	return TestStepResult();

   634 	}

   635 

   636 TPtrC CCTSYIntegrationTestDataCallControl0001::GetTestStepName()

   637 /**

   638  * @return The test step name.

   639  */

   640 	{

   641 	return _L("CCTSYIntegrationTestDataCallControl0001");

   642 	}

   643 

   644 

   645 

   646 CCTSYIntegrationTestDataCallControl0002::CCTSYIntegrationTestDataCallControl0002(CEtelSessionMgr& aEtelSessionMgr)

   647 	: CCTSYIntegrationTestDataCallControlBase(aEtelSessionMgr)

   648 /**

   649  * Constructor.

   650  */

   651 	{

   652 	SetTestStepName(CCTSYIntegrationTestDataCallControl0002::GetTestStepName());

   653 	}

   654 

   655 CCTSYIntegrationTestDataCallControl0002::~CCTSYIntegrationTestDataCallControl0002()

   656 /**

   657  * Destructor.

   658  */

   659 	{

   660 	}

   661 

   662 TVerdict CCTSYIntegrationTestDataCallControl0002::doTestStepL()

   663 /**

   664  * @SYMTestCaseID BA-CTSY-INT-DATC-0002

   665  * @SYMFssID BA/CTSY/DATC-0002

   666  * @SYMTestCaseDesc Make a circuit switched data call.

   667  * @SYMTestPriority High

   668  * @SYMTestActions RCall::HangUp, RMobileCall::NotifyMobileDataCallCapsChange, RCall::NotifyStatusChange, RMobileCall::GetMobileDataCallCaps, RCall::Dial, RCall::GetBearerServiceInfo

   669  * @SYMTestExpectedResults Pass - Data call caps and bearer service info correct.

   670  * @SYMTestType CIT

   671  * @SYMTestCaseDependencies live/automatic

   672  *

   673  * Reason for test: Verify data call caps are correct.

   674  *

   675  * @return - TVerdict code

   676  */

   677 	{

   678 

   679 	//

   680 	// SET UP

   681 	//

   682 	

   683 	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer,KMainPhone);

   684  	

   685  	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone,

   686 				   _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   687 		

   688 	// Get data line 1. 

   689 	RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KDataLine);

   690 

   691 	// Get Call 1.

   692 	RMobileCall& call1= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KDataLine, KCall1);

   693 

   694 	//

   695 	// SET UP END

   696 	//

   697 	

   698 	StartTest();

   699 	

   700 	//

   701 	// TEST START

   702 	//

   703 	

   704 	// ===  Check default caps set by CTSY ===

   705 	RMobileCall::TMobileCallDataCapsV1 dataCallCaps;

   706 	RMobileCall::TMobileCallDataCapsV1Pckg CallCapsPckg(dataCallCaps);

   707 	ASSERT_EQUALS(call1.GetMobileDataCallCaps(CallCapsPckg), KErrNone, _L("RMobileCall::GetMobileDataCallCaps returned an errror"));

   708 

   709 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iSpeedCaps in set of RMobileCall::KCapsSpeedAutobauding

   710 	//         | RMobileCall::KCapsSpeed2400 

   711 	//         | RMobileCall::KCapsSpeed4800 

   712 	//         | RMobileCall::KCapsSpeed9600 

   713 	//         | RMobileCall::KCapsSpeed14400 

   714 	//         | RMobileCall::KCapsSpeed19200 

   715 	//         | RMobileCall::KCapsSpeed28800 

   716 	//         | RMobileCall::KCapsSpeed38400 

   717 	//         | RMobileCall::KCapsSpeed43200 

   718 	//         | RMobileCall::KCapsSpeed56000 

   719 	TUint32 defaultSpeedCaps = RMobileCall::KCapsSpeedAutobauding |

   720                                RMobileCall::KCapsSpeed2400 |

   721                                RMobileCall::KCapsSpeed4800 |

   722                                RMobileCall::KCapsSpeed9600 |

   723                                RMobileCall::KCapsSpeed14400 |

   724                                RMobileCall::KCapsSpeed19200 |

   725                                RMobileCall::KCapsSpeed28800 |

   726                                RMobileCall::KCapsSpeed38400 |

   727                                RMobileCall::KCapsSpeed43200 |

   728                                RMobileCall::KCapsSpeed56000;

   729 	ASSERT_BITS_SET(dataCallCaps.iSpeedCaps, defaultSpeedCaps, KNoUnwantedBits,

   730 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default speed caps"));

   731 

   732 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iServiceCaps in set of 

   733 	//			 RMobileCall::KCapsDataCircuitAsynchronous

   734 	//         | RMobileCall::KCapsDataCircuitAsynchronousRDI 

   735 	//         | RMobileCall::KCapsPADAsyncUDI 

   736 	//         | RMobileCall::KCapsPADAsyncRDI 

   737 	//         | RMobileCall::KCapsPacketAccessSyncUDI 

   738 	//         | RMobileCall::KCapsPacketAccessSyncRDI 

   739 	TUint32 defaultServiceCaps = RMobileCall::KCapsDataCircuitAsynchronous

   740 						         | RMobileCall::KCapsDataCircuitAsynchronousRDI 

   741 						         | RMobileCall::KCapsPADAsyncUDI 

   742 						         | RMobileCall::KCapsPADAsyncRDI 

   743 						         | RMobileCall::KCapsPacketAccessSyncUDI 

   744 						         | RMobileCall::KCapsPacketAccessSyncRDI;

   745 	ASSERT_BITS_SET(dataCallCaps.iServiceCaps, defaultServiceCaps, KNoUnwantedBits,

   746 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default service caps"));

   747 

   748 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iProtocolCaps in set of 

   749 	//			RMobileCall::KCapsProtocolV22bis

   750 	//         | RMobileCall::KCapsProtocolV32 

   751 	//         | RMobileCall::KCapsProtocolV34 

   752 	//         | RMobileCall::KCapsProtocolV110 

   753 	//         | RMobileCall::KCapsProtocolV120 

   754 	//         | RMobileCall::KCapsProtocolX31FlagStuffing 

   755 	//         | RMobileCall::KCapsProtocolPIAFS 

   756 	TUint32 defaultProtocolCaps = 	RMobileCall::KCapsProtocolV22bis

   757 									| RMobileCall::KCapsProtocolV32 

   758 									| RMobileCall::KCapsProtocolV34 

   759 									| RMobileCall::KCapsProtocolV110 

   760 									| RMobileCall::KCapsProtocolV120 

   761 									| RMobileCall::KCapsProtocolX31FlagStuffing 

   762 									| RMobileCall::KCapsProtocolPIAFS;

   763 	ASSERT_BITS_SET(dataCallCaps.iProtocolCaps, defaultProtocolCaps, KNoUnwantedBits,

   764 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default protocol caps"));

   765 

   766 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iQoSCaps in set of 

   767 	//			RMobileCall::KCapsTransparent

   768 	//         | RMobileCall::KCapsNonTransparent 

   769 	//         | RMobileCall::KCapsTransparentPreferred 

   770 	//         | RMobileCall::KCapsNonTransparentPreferred 

   771 	TUint32 defaultQoSCaps =  RMobileCall::KCapsTransparent

   772 							| RMobileCall::KCapsNonTransparent 

   773 							| RMobileCall::KCapsTransparentPreferred 

   774 							| RMobileCall::KCapsNonTransparentPreferred;

   775 	ASSERT_BITS_SET(dataCallCaps.iQoSCaps, defaultQoSCaps, KNoUnwantedBits,

   776 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default QoS caps"));

   777 

   778 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iHscsdSupport=ETrue

   779 	ASSERT_TRUE(dataCallCaps.iHscsdSupport != EFalse, _L("RMobileCall::GetMobileDataCallCaps returned hscsd support EFalse"));

   780 

   781 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iRLPVersionCaps in set of 

   782 	//			 RMobileCall::KCapsRLPSingleLinkVersion0

   783 	//         | RMobileCall::KCapsRLPSingleLinkVersion1 

   784 	//         | RMobileCall::KCapsRLPMultiLinkVersion2 

   785 	TUint32 defaultRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion0

   786 									| RMobileCall::KCapsRLPSingleLinkVersion1 

   787 									| RMobileCall::KCapsRLPMultiLinkVersion2;

   788 	ASSERT_BITS_SET(dataCallCaps.iRLPVersionCaps, defaultRLPVersionCaps, KNoUnwantedBits,

   789 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default RLPVersion caps"));

   790 

   791 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iV42bisCaps in set of 

   792 	//			RMobileCall::KCapsV42bisTxDirection

   793 	//         | RMobileCall::KCapsV42bisRxDirection 

   794 	//         | RMobileCall::KCapsV42bisBothDirections 

   795 	TUint32 defaultV42bisCaps = RMobileCall::KCapsV42bisTxDirection

   796 								| RMobileCall::KCapsV42bisRxDirection 

   797 								| RMobileCall::KCapsV42bisBothDirections;

   798 	ASSERT_BITS_SET(dataCallCaps.iV42bisCaps, defaultV42bisCaps, KNoUnwantedBits,

   799 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default V42bis caps"));

   800 

   801 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iAsymmetryCaps in set of 

   802 	// 			RMobileCall::KCapsAsymmetryNoPreference

   803 	//         | RMobileCall::KCapsAsymmetryDownlink 

   804 	//         | RMobileCall::KCapsAsymmetryUplink 

   805 	TUint32 defaultAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference

   806 									| RMobileCall::KCapsAsymmetryDownlink 

   807 									| RMobileCall::KCapsAsymmetryUplink;

   808 	ASSERT_BITS_SET(dataCallCaps.iAsymmetryCaps, defaultAsymmetryCaps, KNoUnwantedBits,

   809 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default asymmetry caps"));

   810 

   811 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iCodingCaps in set of 

   812 	//			RMobileCall::KCapsTchCoding48

   813 	//         | RMobileCall::KCapsTchCoding96 

   814 	//         | RMobileCall::KCapsTchCoding144 

   815 	TUint32 defaultCodingCaps = RMobileCall::KCapsTchCoding48

   816 								| RMobileCall::KCapsTchCoding96 

   817 								| RMobileCall::KCapsTchCoding144;

   818 	ASSERT_BITS_SET(dataCallCaps.iCodingCaps, defaultCodingCaps, KNoUnwantedBits,

   819 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default coding caps"));

   820 

   821 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iMClass = 0x6

   822 	ASSERT_EQUALS(dataCallCaps.iMClass, 0x6, _L("RMobileCall::GetMobileDataCallCaps.iMClass did not return 0x6"));

   823 

   824 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iMaxRxTimeSlots = 0x3

   825 	ASSERT_EQUALS(dataCallCaps.iMaxRxTimeSlots, 0x3, _L("RMobileCall::GetMobileDataCallCaps.iMaxRxTimeSlots did not return 0x3"));

   826 	

   827 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iMaxTxTimeSlots = 0x2

   828 	ASSERT_EQUALS(dataCallCaps.iMaxTxTimeSlots, 0x2, _L("RMobileCall::GetMobileDataCallCaps.iMaxTxTimeSlots did not return 0x2"));

   829 	

   830 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iTotalRxTxTimeSlots = 0x4

   831 	ASSERT_EQUALS(dataCallCaps.iTotalRxTxTimeSlots, 0x4, _L("RMobileCall::GetMobileDataCallCaps.iTotalRxTxTimeSlots did not return 0x4"));

   832 	

   833 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iUserInitUpgrade=EFalse

   834 	ASSERT_TRUE(dataCallCaps.iUserInitUpgrade == EFalse, _L("RMobileCall::GetMobileDataCallCaps.iUserInitUpgrade did not return EFalse"));

   835 

   836 	// ===  Check bearer service with no call connected ===

   837 	RCall::TBearerService bearerService;

   838 

   839 	// Check RCall::GetBearerServiceInfo returns KErrNotFound

   840 	ASSERT_EQUALS(call1.GetBearerServiceInfo(bearerService), KErrNotFound, 

   841 				  _L("RCall::GetBearerServiceInfo didn't return KErrNotFound"));

   842 

   843 	// Check RCall::GetBearerServiceInfo returns aBearerService.iBearerCaps = RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown

   844 	TUint bearerCaps = RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown;

   845 	ASSERT_BITS_SET(bearerService.iBearerCaps, bearerCaps, KNoUnwantedBits,

   846 					_L("RCall::GetBearerServiceInfo returned wrong bearer caps"));

   847 	

   848 	// Check RCall::GetBearerServiceInfo returns aBearerService.iBearerSpeed=RCall::EBearerDataUnknown

   849     TUint bearerSpeed = RCall::EBearerDataUnknown;

   850 	ASSERT_BITS_SET(bearerService.iBearerSpeed, bearerSpeed, KNoUnwantedBits,

   851 					_L("RCall::GetBearerServiceInfo returned wrong bearer speed"));

   852 	

   853 	// ===  Dial a call with call params ===

   854 

   855 	// Set up a RMobileCall::TMobileDataCallParamsV1 with 

   856 	RMobileCall::TMobileDataCallParamsV1 mobileDataCallParams;

   857 	// iService = RMobileCall::EServiceDataCircuitAsync 

   858 	mobileDataCallParams.iService = RMobileCall::EServiceDataCircuitAsync;

   859 	// iSpeed = RMobileCall::ESpeed9600 

   860 	mobileDataCallParams.iSpeed = RMobileCall::ESpeed9600;

   861 	// iProtocol = RMobileCall::EProtocolV32 

   862 	mobileDataCallParams.iProtocol = RMobileCall::EProtocolV32;

   863 	// iQoS = RMobileCall::EQoSNonTransparent 

   864 	mobileDataCallParams.iQoS = RMobileCall::EQoSNonTransparent;

   865 

   866 	RMobileCall::TMobileDataCallParamsV1Pckg mobileDataCallParamsPkg(mobileDataCallParams);

   867 

   868 	// post notifier for RCall::NotifyStatusChange

   869 	TCoreEtelRequestStatus<RCall> notifyCallStatusChangeStatus (call1,&RCall::NotifyStatusChangeCancel);

   870 	CleanupStack::PushL(notifyCallStatusChangeStatus);

   871 	RCall::TStatus callStatus;

   872 	call1.NotifyStatusChange(notifyCallStatusChangeStatus,callStatus);

   873 

   874 	// Post notify RMobileCall::NotifyMobileDataCallCapsChange

   875 	RMobileCall::TMobileCallDataCapsV1 notifydataCallCaps;

   876 	RMobileCall::TMobileCallDataCapsV1Pckg notifydataCallCapsPckg(notifydataCallCaps);

   877 	TExtEtelRequestStatus notifydataCallCapsStatus(call1, EMobileCallNotifyMobileDataCallCapsChange);

   878 	CleanupStack::PushL(notifydataCallCapsStatus);

   879 	call1.NotifyMobileDataCallCapsChange(notifydataCallCapsStatus, notifydataCallCapsPckg);

   880 

   881 	// Dial a number that answers using the data call params 

   882 	TCoreEtelRequestStatus<RMobileCall> dialStatus(call1, &RCall::DialCancel);

   883 	CleanupStack::PushL(dialStatus);		

   884 	TPtrC number;

   885 	ASSERT_TRUE(GetStringFromConfig(KIniDataNumSection, KIniDataNumber1, number) != EFalse,  

   886 			_L("GetStringFromConfig did not complete as expected"));

   887 	call1.Dial(dialStatus,mobileDataCallParamsPkg, number);

   888 	// Wait for completion. 

   889 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeVeryLong), KErrNone, 

   890 			_L("RCall::Dial timed-out"));

   891 	ASSERT_EQUALS(dialStatus.Int(), KErrNone, 

   892 			_L("RCall::Dial returned an error"));

   893 

   894 	// Check RCall::NotifyStatusChange completes with EStatusConnected.

   895 	RCall::TStatus expectedCallStatus = RCall::EStatusConnected;

   896 	const TInt expectedStatus = KErrNone;

   897 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   898 														 notifyCallStatusChangeStatus,

   899 														 callStatus,

   900 														 expectedCallStatus,

   901 														 expectedStatus);

   902 

   903 	// ===  Check mobile data call caps ===

   904 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifydataCallCapsStatus, ETimeMedium), KErrNone, _L("RMobileCall::NotifyMobileDataCallCapsChange timed-out"));

   905 

   906 	// Check RMobileCall::NotifyMobileDataCallCapsChange completes with aCaps.iHscsdSupport=EFalse

   907 	ASSERT_TRUE(notifydataCallCaps.iHscsdSupport == EFalse, _L("RMobileCall::NotifyMobileDataCallCapsChange returned hscsd did not support ETrue"));

   908 	

   909 	// Check RMobileCall::NotifyMobileDataCallCapsChange completes with aCaps.iSpeedCaps=RMobileCall::KCapsSpeed9600

   910 	ASSERT_BITS_SET(notifydataCallCaps.iSpeedCaps, RMobileCall::KCapsSpeed9600, KNoUnwantedBits,

   911 					_L("RMobileCall::NotifyMobileDataCallCapsChange returned wrong speed caps"));

   912 	

   913 	// Check RMobileCall::NotifyMobileDataCallCapsChange completes with aCaps.iProtocolCaps=RMobileCall::KCapsProtocolV32

   914 	ASSERT_BITS_SET(notifydataCallCaps.iProtocolCaps, RMobileCall::KCapsProtocolV32, KNoUnwantedBits,

   915 					_L("RMobileCall::NotifyMobileDataCallCapsChange returned wrong protocol caps"));

   916 

   917 	// Check RMobileCall::NotifyMobileDataCallCapsChange completes with aCaps.iQoSCaps=RMobileCall::KCapsNonTransparent

   918 	ASSERT_BITS_SET(notifydataCallCaps.iQoSCaps, RMobileCall::KCapsNonTransparent, KNoUnwantedBits,

   919 					_L("RMobileCall::NotifyMobileDataCallCapsChange returned wrong QoS caps"));

   920 

   921 	// Check RMobileCall::NotifyMobileDataCallCapsChange completes with aCaps.iServiceCaps=RMobileCall::KCapsDataCircuitAsynchronous

   922 	ASSERT_BITS_SET(notifydataCallCaps.iServiceCaps, RMobileCall::KCapsDataCircuitAsynchronous, KNoUnwantedBits,

   923 					_L("RMobileCall::NotifyMobileDataCallCapsChange returned wrong service caps"));

   924 

   925 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iHscsdSupport=ETrue

   926 	ASSERT_TRUE(dataCallCaps.iHscsdSupport, _L("RMobileCall::GetMobileDataCallCaps returned hscsd support ETrue"));

   927 

   928 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iSpeedCaps=RMobileCall::KCapsSpeed9600

   929 	ASSERT_EQUALS(call1.GetMobileDataCallCaps(CallCapsPckg), KErrNone, _L("RMobileCall::GetMobileDataCallCaps returned an errror "));

   930 	ASSERT_BITS_SET(dataCallCaps.iSpeedCaps, RMobileCall::KCapsSpeed9600, KNoUnwantedBits,

   931 					_L("RMobileCall::GetMobileDataCallCaps returned wrong speed caps"));

   932 

   933 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iProtocolCaps=RMobileCall::KCapsProtocolV32

   934 	ASSERT_BITS_SET(dataCallCaps.iProtocolCaps, RMobileCall::KCapsProtocolV32, KNoUnwantedBits,

   935 					_L("RMobileCall::GetMobileDataCallCaps returned wrong protocol caps"));

   936 

   937 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iQoSCaps=RMobileCall::KCapsNonTransparent

   938 	ASSERT_BITS_SET(dataCallCaps.iQoSCaps, RMobileCall::KCapsNonTransparent, KNoUnwantedBits,

   939 					_L("RMobileCall::GetMobileDataCallCaps returned wrong QoS caps"));

   940 

   941 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iServiceCaps=RMobileCall::KCapsDataCircuitAsynchronous

   942 	ASSERT_BITS_SET(dataCallCaps.iServiceCaps, RMobileCall::KCapsDataCircuitAsynchronous, KNoUnwantedBits,

   943 					_L("RMobileCall::GetMobileDataCallCaps returned wrong service caps"));

   944 

   945 	// ===  Get bearer service info with call connected ===

   946 

   947 	// Check RCall::GetBearerServiceInfo returns KErrNone

   948 	ASSERT_EQUALS(call1.GetBearerServiceInfo(bearerService), KErrNone, 

   949 				  _L("RCall::GetBearerServiceInfo didn't return KErrNone"));

   950 

   951 	// Check RCall::GetBearerServiceInfo returns aBearerService.iBearerCaps !=RCall::KBearerCapsCompressionUnknown

   952 	ASSERT_TRUE(bearerService.iBearerCaps != RCall::KBearerCapsCompressionUnknown, _L("RCall::GetBearerServiceInfo returned wrong bearer caps compression"));

   953 

   954 	// Check RCall::GetBearerServiceInfo returns aBearerService.iBearerCaps != RCall::KBearerCapsProtocolUnknown

   955 	ASSERT_TRUE(bearerService.iBearerCaps != RCall::KBearerCapsProtocolUnknown, _L("RCall::GetBearerServiceInfo returned wrong bearer caps protocol"));

   956 

   957 	// Check RCall::GetBearerServiceInfo returns aBearerService.iBearerSpeed !=RCall::EBearerDataUnknown

   958 	ASSERT_TRUE(bearerService.iBearerSpeed != RCall::EBearerDataUnknown, _L("RCall::GetBearerServiceInfo returned wrong bearer speed"));

   959 

   960 	// ===  Hang up call ===

   961 	call1.NotifyStatusChange(notifyCallStatusChangeStatus,callStatus);

   962 

   963 	// Hang up call with RCall::HangUp 

   964 	TCoreEtelRequestStatus<RCall> hangUpStatus (call1,&RCall::HangUpCancel);	

   965 	CleanupStack::PushL(hangUpStatus);

   966 	call1.HangUp(hangUpStatus);

   967 	ASSERT_EQUALS(WaitForRequestWithTimeOut(hangUpStatus, ETimeMedium), KErrNone, _L("RCall::HangUp timed-out"));

   968 	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RCall::CallHangUp returned an error"));

   969 

   970 	// Check RCall::NotifyStatusChange completes with EStatusIdle.

   971 	expectedCallStatus = RCall::EStatusIdle;

   972 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   973 														 notifyCallStatusChangeStatus,

   974 														 callStatus,

   975 														 expectedCallStatus,

   976 														 expectedStatus);

   977 

   978 	// ===  Check caps reset ===

   979 	ASSERT_EQUALS(call1.GetMobileDataCallCaps(CallCapsPckg), KErrNone, _L("RMobileCall::GetMobileDataCallCaps returned an errror"));

   980 

   981 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iSpeedCaps in set of 

   982 	//			 RMobileCall::KCapsSpeedAutobauding

   983 	//         | RMobileCall::KCapsSpeed2400 

   984 	//         | RMobileCall::KCapsSpeed4800 

   985 	//         | RMobileCall::KCapsSpeed9600 

   986 	//         | RMobileCall::KCapsSpeed14400 

   987 	//         | RMobileCall::KCapsSpeed19200 

   988 	//         | RMobileCall::KCapsSpeed28800 

   989 	//         | RMobileCall::KCapsSpeed38400 

   990 	//         | RMobileCall::KCapsSpeed43200 

   991 	//         | RMobileCall::KCapsSpeed56000 

   992 	defaultSpeedCaps = RMobileCall::KCapsSpeedAutobauding |

   993 						 RMobileCall::KCapsSpeed2400 |

   994 						 RMobileCall::KCapsSpeed4800 |

   995 						 RMobileCall::KCapsSpeed9600 |

   996 						 RMobileCall::KCapsSpeed14400 |

   997 						 RMobileCall::KCapsSpeed19200 |

   998 						 RMobileCall::KCapsSpeed28800 |

   999 						 RMobileCall::KCapsSpeed38400 |

  1000 						 RMobileCall::KCapsSpeed43200 |

  1001 						 RMobileCall::KCapsSpeed56000;

  1002 	ASSERT_BITS_SET(dataCallCaps.iSpeedCaps, defaultSpeedCaps, KNoUnwantedBits,

  1003 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default speed caps"));

  1004 

  1005 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iServiceCaps in set of 

  1006 	//RMobileCall::KCapsDataCircuitAsynchronous

  1007 	//         | RMobileCall::KCapsDataCircuitAsynchronousRDI 

  1008 	//         | RMobileCall::KCapsPADAsyncUDI 

  1009 	//         | RMobileCall::KCapsPADAsyncRDI 

  1010 	//         | RMobileCall::KCapsPacketAccessSyncUDI 

  1011 	//         | RMobileCall::KCapsPacketAccessSyncRDI 

  1012 	defaultServiceCaps = RMobileCall::KCapsDataCircuitAsynchronous

  1013 				         | RMobileCall::KCapsDataCircuitAsynchronousRDI 

  1014 				         | RMobileCall::KCapsPADAsyncUDI 

  1015 				         | RMobileCall::KCapsPADAsyncRDI 

  1016 				         | RMobileCall::KCapsPacketAccessSyncUDI 

  1017 				         | RMobileCall::KCapsPacketAccessSyncRDI;

  1018 	ASSERT_BITS_SET(dataCallCaps.iServiceCaps, defaultServiceCaps, KNoUnwantedBits,

  1019 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default service caps"));

  1020 

  1021 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iProtocolCaps in set of 

  1022 	//			RMobileCall::KCapsProtocolV22bis

  1023 	//         | RMobileCall::KCapsProtocolV32 

  1024 	//         | RMobileCall::KCapsProtocolV34 

  1025 	//         | RMobileCall::KCapsProtocolV110 

  1026 	//         | RMobileCall::KCapsProtocolV120 

  1027 	//         | RMobileCall::KCapsProtocolX31FlagStuffing 

  1028 	//         | RMobileCall::KCapsProtocolPIAFS 

  1029 	defaultProtocolCaps = 	RMobileCall::KCapsProtocolV22bis

  1030 							| RMobileCall::KCapsProtocolV32 

  1031 							| RMobileCall::KCapsProtocolV34 

  1032 							| RMobileCall::KCapsProtocolV110 

  1033 							| RMobileCall::KCapsProtocolV120 

  1034 							| RMobileCall::KCapsProtocolX31FlagStuffing 

  1035 							| RMobileCall::KCapsProtocolPIAFS;

  1036 	ASSERT_BITS_SET(dataCallCaps.iProtocolCaps, defaultProtocolCaps, KNoUnwantedBits,

  1037 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default protocol caps"));

  1038 

  1039 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iQoSCaps in set of 

  1040 	// 			RMobileCall::KCapsTransparent

  1041 	//         | RMobileCall::KCapsNonTransparent 

  1042 	//         | RMobileCall::KCapsTransparentPreferred 

  1043 	//         | RMobileCall::KCapsNonTransparentPreferred 

  1044 	defaultQoSCaps =  RMobileCall::KCapsTransparent

  1045 					| RMobileCall::KCapsNonTransparent 

  1046 					| RMobileCall::KCapsTransparentPreferred 

  1047 					| RMobileCall::KCapsNonTransparentPreferred;

  1048 	ASSERT_BITS_SET(dataCallCaps.iQoSCaps, defaultQoSCaps, KNoUnwantedBits,

  1049 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default QoS caps"));

  1050 

  1051 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iHscsdSupport=ETrue

  1052 	ASSERT_TRUE(dataCallCaps.iHscsdSupport != EFalse, _L("RMobileCall::GetMobileDataCallCaps returned hscsd support EFalse"));

  1053 

  1054 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iRLPVersionCaps in set of 

  1055 	//			 RMobileCall::KCapsRLPSingleLinkVersion0

  1056 	//         | RMobileCall::KCapsRLPSingleLinkVersion1 

  1057 	//         | RMobileCall::KCapsRLPMultiLinkVersion2 

  1058 	defaultRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion0

  1059 							| RMobileCall::KCapsRLPSingleLinkVersion1 

  1060 							| RMobileCall::KCapsRLPMultiLinkVersion2;

  1061 	ASSERT_BITS_SET(dataCallCaps.iRLPVersionCaps, defaultRLPVersionCaps, KNoUnwantedBits,

  1062 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default RLPVersion caps"));

  1063 

  1064 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iV42bisCaps in set of 

  1065 	//			RMobileCall::KCapsV42bisTxDirection

  1066 	//         | RMobileCall::KCapsV42bisRxDirection 

  1067 	//         | RMobileCall::KCapsV42bisBothDirections 

  1068 	defaultV42bisCaps = RMobileCall::KCapsV42bisTxDirection

  1069 						| RMobileCall::KCapsV42bisRxDirection 

  1070 						| RMobileCall::KCapsV42bisBothDirections;

  1071 	ASSERT_BITS_SET(dataCallCaps.iV42bisCaps, defaultV42bisCaps, KNoUnwantedBits,

  1072 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default V42bis caps"));

  1073 

  1074 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iAsymmetryCaps in set of 

  1075 	// 			RMobileCall::KCapsAsymmetryNoPreference

  1076 	//         | RMobileCall::KCapsAsymmetryDownlink 

  1077 	//         | RMobileCall::KCapsAsymmetryUplink 

  1078 	defaultAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference

  1079 							| RMobileCall::KCapsAsymmetryDownlink 

  1080 							| RMobileCall::KCapsAsymmetryUplink;

  1081 	ASSERT_BITS_SET(dataCallCaps.iAsymmetryCaps, defaultAsymmetryCaps, KNoUnwantedBits,

  1082 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default asymmetry caps"));

  1083 

  1084 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iCodingCaps in set of 

  1085 	//			RMobileCall::KCapsTchCoding48

  1086 	//         | RMobileCall::KCapsTchCoding96 

  1087 	//         | RMobileCall::KCapsTchCoding144 

  1088 	defaultCodingCaps = RMobileCall::KCapsTchCoding48

  1089 						| RMobileCall::KCapsTchCoding96 

  1090 						| RMobileCall::KCapsTchCoding144;

  1091 	ASSERT_BITS_SET(dataCallCaps.iCodingCaps, defaultCodingCaps, KNoUnwantedBits,

  1092 					_L("RMobileCall::GetMobileDataCallCaps returned wrong default coding caps"));

  1093 

  1094 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iMClass = 0x6

  1095 	ASSERT_EQUALS(dataCallCaps.iMClass, 0x6, _L("RMobileCall::GetMobileDataCallCaps.iMClass did not return 0x6"));

  1096 

  1097 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iMaxRxTimeSlots = 0x3

  1098 	ASSERT_EQUALS(dataCallCaps.iMaxRxTimeSlots, 0x3, _L("RMobileCall::GetMobileDataCallCaps.iMaxRxTimeSlots did not return 0x3"));

  1099 	

  1100 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iMaxTxTimeSlots = 0x2

  1101 	ASSERT_EQUALS(dataCallCaps.iMaxTxTimeSlots, 0x2, _L("RMobileCall::GetMobileDataCallCaps.iMaxTxTimeSlots did not return 0x2"));

  1102 	

  1103 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iTotalRxTxTimeSlots = 0x4

  1104 	ASSERT_EQUALS(dataCallCaps.iTotalRxTxTimeSlots, 0x4, _L("RMobileCall::GetMobileDataCallCaps.iTotalRxTxTimeSlots did not return 0x4"));

  1105 	

  1106 	// Check RMobileCall::GetMobileDataCallCaps returns aCaps.iUserInitUpgrade=EFalse

  1107 	ASSERT_TRUE(dataCallCaps.iUserInitUpgrade == EFalse, _L("RMobileCall::GetMobileDataCallCaps.iUserInitUpgrade did not return EFalse"));

  1108 

  1109 	// ===  Check bearer service with no call connected ===

  1110 

  1111 	// Check RCall::GetBearerServiceInfo returns KErrNotFound

  1112 	ASSERT_EQUALS(call1.GetBearerServiceInfo(bearerService), KErrNotFound, 

  1113 				  _L("RCall::GetBearerServiceInfo didn't return KErrNotFound"));

  1114 

  1115 	// Check RCall::GetBearerServiceInfo returns aBearerService.iBearerCaps=RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown

  1116 	bearerCaps = RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown;

  1117 	ASSERT_BITS_SET(bearerService.iBearerCaps, bearerCaps, KNoUnwantedBits,

  1118 					_L("RCall::GetBearerServiceInfo returned wrong bearer caps"));

  1119 	// Check RCall::GetBearerServiceInfo returns aBearerService.iBearerSpeed=RCall::EBearerDataUnknown

  1120 	ASSERT_BITS_SET(bearerService.iBearerSpeed, RCall::EBearerDataUnknown, KNoUnwantedBits,

  1121 					_L("RCall::GetBearerServiceInfo returned wrong bearer speed"));

  1122 

  1123 

  1124 	//

  1125 	// TEST END

  1126 	//

  1127 

  1128     StartCleanup();

  1129 	

  1130 	// Pop

  1131 	// notifyCallStatusChangeStatus

  1132 	// notifydataCallCapsStatus

  1133 	// dialStatus

  1134 	// hangUpStatus

  1135 	CleanupStack::PopAndDestroy(4, &notifyCallStatusChangeStatus);