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 MultimediaCallControl functional unit.

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include "cctsyintegrationtestmultimediacallcontrol.h"

    23 #include "cctsyinidata.h"

    24 

    25 /*

    26 _LIT8(KWriteTestData, "Some data");

    27 */

    28 	

    29 CCTSYIntegrationTestMultimediaCallControlBase::CCTSYIntegrationTestMultimediaCallControlBase(CEtelSessionMgr& aEtelSessionMgr)

    30 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr),

    31 			iNetworkTestHelper(*this),

    32 			iCallControlTestHelper(*this)

    33 /**

    34  * Constructor

    35  */

    36 	{

    37 	}

    38 

    39 CCTSYIntegrationTestMultimediaCallControlBase::~CCTSYIntegrationTestMultimediaCallControlBase()

    40 /*

    41  * Destructor

    42  */

    43 	{

    44 	}

    45 	

    46 

    47 CCTSYIntegrationTestMultimediaCallControl0001::CCTSYIntegrationTestMultimediaCallControl0001(CEtelSessionMgr& aEtelSessionMgr)

    48 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

    49 /**

    50  * Constructor.

    51  */

    52 	{

    53 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0001::GetTestStepName());

    54 	}

    55 

    56 CCTSYIntegrationTestMultimediaCallControl0001::~CCTSYIntegrationTestMultimediaCallControl0001()

    57 /**

    58  * Destructor.

    59  */

    60 	{

    61 	}

    62 

    63 TVerdict CCTSYIntegrationTestMultimediaCallControl0001::doTestStepL()

    64 /**

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

    66  * @SYMFssID BA/CTSY/MMCC-0001

    67  * @SYMTestCaseDesc Ensure a video call can be made.

    68  * @SYMTestPriority High

    69  * @SYMTestActions RCall::LoanDataPort, RCall::RecoverDataPort, RCall:HangUp, RCall::DialCancel, RCall::GetCallParams

    70  * @SYMTestExpectedResults Pass - Dialling multimedia call is successful when parameters are correct. Cancelling dial is successful.

    71  * @SYMTestType CIT

    72  * @SYMTestCaseDependencies live/manual

    73  *

    74  *

    75  * @return - TVerdict code

    76  */

    77 	{

    78 

    79 	//

    80 	// SET UP

    81 	//

    82 

    83 	

    84 	// Ensure phone is camped on a valid cell. 

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

    86 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

    87 	

    88 	// Get data line 1. 

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

    90 	

    91 	// Get call 1. 

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

    93 

    94     // Check current networkmode returns ENetworkModeWcdma

    95 	RMobilePhone::TMobilePhoneNetworkMode mode;

    96 	CHECK_EQUALS_L(phone.GetCurrentMode(mode), KErrNone, _L("RMobilePhone::GetCurrentMode returned with an error"));

    97 	CHECK_EQUALS_L(mode, RMobilePhone::ENetworkModeWcdma, _L("RMobilePhone::GetCurrentMode did not return ENetworkModeWcdma as expected"));

    98 		

    99 	//

   100 	// SET UP END

   101 	//

   102 	

   103 	StartTest();

   104 	

   105 	//

   106 	// TEST START

   107 	//

   108 

   109 	

   110 	// 1. Set up multimedia mobile data call parameters. 

   111 	RMobileCall::TMobileHscsdCallParamsV1 multimediaParams;

   112 	RMobileCall::TMobileHscsdCallParamsV1Pckg checkParamsPkg(multimediaParams);

   113 	

   114 	// valid parameters 

   115 	multimediaParams.iIdRestrict = RMobileCall::ESendMyId;

   116 	multimediaParams.iAckTimer = 20;

   117 	multimediaParams.iMSToModemWindowSize = 2;

   118 	multimediaParams.iModemToMSWindowSize = 2;	

   119 	multimediaParams.iProtocol = RMobileCall::EProtocolPstnMultimedia;

   120 	multimediaParams.iQoS = RMobileCall::EQoSNonTransparent;

   121 	multimediaParams.iRLPVersion = RMobileCall::ERLPSingleLinkVersion0;

   122 	multimediaParams.iResequencingPeriod = 1;

   123 	multimediaParams.iRetransmissionAttempts = 2;

   124 	multimediaParams.iService = RMobileCall::EServiceDataCircuitAsync;

   125 	multimediaParams.iSpeed = RMobileCall::ESpeed64000;

   126 	multimediaParams.iUseEdge = EFalse;

   127 	multimediaParams.iV42bisCodewordsNum = 0;

   128     multimediaParams.iV42bisMaxStringLength = 0;

   129     multimediaParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   130 	multimediaParams.iAsymmetry = RMobileCall::EAsymmetryDownlink;

   131 	multimediaParams.iCodings = RMobileCall::KCapsAiurCoding144;

   132 	multimediaParams.iUserInitUpgrade = EFalse;

   133 	multimediaParams.iMaxTimeSlots = 15;

   134 	multimediaParams.iWantedRxTimeSlots = 15;

   135 	multimediaParams.iWantedAiur = RMobileCall::EAiurBpsUnspecified;

   136 

   137 	// post a notifier for RLine::NotifyStatusChange

   138 	TCoreEtelRequestStatus<RLine> notifyStatusChangeStatus (mobileLine,&RLine::NotifyStatusChangeCancel);

   139 	CleanupStack::PushL(notifyStatusChangeStatus);

   140 	RCall::TStatus lineStatus;

   141 	mobileLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   142 	

   143 	// Dial a number that answers. 

   144 	TPtrC number; 

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

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

   147 	CleanupStack::PushL(dialStatus);

   148 

   149     // Failing CSD calls (see $CTSYProblem described below).

   150     // code can be added in after multimedia calls are working.

   151 

   152 	// $CTSYProblem: dial returns -18 or -6 depending of selected parametes (protocol)

   153     // EProtocolPstnMultimedia = -6, EProtocolV34 = -18

   154     // All CSD call are currently failing, this is not a CTSY problem because CTSY has no control over this issue

   155     /*

   156 	call1.Dial(dialStatus, checkParamsPkg, number); 

   157 	TEST_CHECK_POINT_L(_L("Couldn't dial a call, no point continuing."));

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

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

   160 	

   161 	// Verify line status goes from ringing to connected. 

   162 	RCall::TStatus expectedLineStatus = RCall::EStatusRinging;

   163 	const TInt expectedStatus = KErrNone;

   164 	

   165 	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

   166 														 notifyStatusChangeStatus,

   167 														 lineStatus,

   168 														 expectedLineStatus,

   169 														 expectedStatus);

   170 	

   171 	mobileLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);													 													 

   172 	expectedLineStatus = RCall::EStatusConnected;

   173 	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

   174 														 notifyStatusChangeStatus,

   175 														 lineStatus,

   176 														 expectedLineStatus,

   177 														 expectedStatus);

   178 	// Loan comm port.

   179 	RCall::TCommPort commPort;

   180 	ASSERT_EQUALS(call1.LoanDataPort(commPort), KErrNone, _L("RCall::LoanCommPort returned an error"));

   181 	

   182 	// Get call parameters with RMobileCall::TMobileDataCallParamsVx and verify it is as expected. 

   183 	ASSERT_EQUALS(call1.GetCallParams(checkParamsPkg), KErrNone, _L("RCall::GetCallParams returned an error"));

   184 	ASSERT_TRUE(multimediaParams.iSpeed = RMobileCall::ESpeed64000, _L("RCall::GetCallParams returned wrongly RMobileCall::ESpeedUnspecified"));

   185 	ASSERT_TRUE(multimediaParams.iProtocol = RMobileCall::EProtocolPstnMultimedia, _L("TMobileDataCallParamsV1 returns aParams.iProtocol"));

   186 	ASSERT_EQUALS(multimediaParams.iService,  RMobileCall::EServiceDataCircuitAsync, _L("RCall::GetCallParams service was not the same that used in dial"));

   187 	 	

   188 	// Send some data. 

   189 	RCommServ cs;

   190 	cs.Connect();

   191 	RComm port;

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

   193 	TRequestStatus writeStatus;

   194 	port.Write(writeStatus, KWriteTestData); 

   195 	port.Close();

   196 	cs.Close();

   197 	

   198 	// Recover comm port. 

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

   200 

   201 	// Hang up. 

   202 	*/

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

   204 	CleanupStack::PushL(hangUpStatus);

   205     

   206     /*

   207 	call1.HangUp(hangUpStatus);

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

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

   210 	*/

   211 	

   212 	// 2. Set up multimedia mobile data call parameters. 

   213 	RMobileCall::TMobileHscsdCallParamsV1 multimediaParams2;

   214 	RMobileCall::TMobileHscsdCallParamsV1Pckg checkParamsPkg2(multimediaParams2);

   215 	

   216 	// valid parameters 

   217 	multimediaParams2.iIdRestrict = RMobileCall::ESendMyId;

   218 	multimediaParams2.iAckTimer = 20;

   219 	multimediaParams2.iMSToModemWindowSize = 2;

   220 	multimediaParams2.iModemToMSWindowSize = 2;	

   221 	multimediaParams2.iProtocol = RMobileCall::EProtocolPstnMultimedia;

   222 	multimediaParams2.iQoS = RMobileCall::EQoSNonTransparent;

   223 	multimediaParams2.iRLPVersion = RMobileCall::ERLPSingleLinkVersion0;

   224 	multimediaParams2.iResequencingPeriod = 1;

   225 	multimediaParams2.iRetransmissionAttempts = 2;

   226 	multimediaParams2.iService = RMobileCall::EServiceDataCircuitAsync;

   227 	multimediaParams2.iSpeed = RMobileCall::ESpeed64000;

   228 	multimediaParams2.iUseEdge = EFalse;

   229 	multimediaParams2.iV42bisCodewordsNum = 0;

   230     multimediaParams2.iV42bisMaxStringLength = 0;

   231     multimediaParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   232     multimediaParams.iMaxTimeSlots = 15;

   233 	multimediaParams.iWantedRxTimeSlots = 15;

   234 	multimediaParams.iWantedAiur = RMobileCall::EAiurBpsUnspecified;

   235 	

   236 	// post notifier for RCall::NotifyStatusChange

   237 	RCall::TStatus callStatus;

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

   239 	CleanupStack::PushL(notifyCallStatusChangeStatus);

   240 	call1.NotifyStatusChange(notifyCallStatusChangeStatus,callStatus);

   241 

   242 	/* 

   243 	// post a notifier for RLine::NotifyStatusChange

   244 	mobileLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   245 	

   246 	// Dial a number which does not answer.  

   247 	ASSERT_TRUE(GetStringFromConfig(KIniDataNumSection, KIniDataNumber2, number) != EFalse, _L("CTestStep::GetStringFromConfig did not complete as expected"));

   248 	// $CTSYProblem: dial returns -18 or -6 depending of selected parametes (protocol)

   249     // EProtocolPstnMultimedia = -6, EProtocolV34 = -18

   250     // All CSD call are currently failing, this is not a CTSY problem because CTSY has no control over this issue

   251 

   252 	call1.Dial(dialStatus, checkParamsPkg2, number); 

   253 	TEST_CHECK_POINT_L(_L("Couldn't dial a call, no point continuing."));

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

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

   256 	

   257 	// Verify line status goes to ringing. 

   258 	expectedLineStatus = RCall::EStatusRinging;

   259 	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

   260 														 notifyStatusChangeStatus,

   261 														 lineStatus,

   262 														 expectedLineStatus,

   263 														 expectedStatus);

   264 														 

   265 	// Cancel dialling. 

   266 	call1.DialCancel();

   267 	

   268 	

   269 	// Verify call and line status is idle. 

   270 	RCall::TStatus expectedCallStatus = RCall::EStatusIdle;

   271 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   272 														 notifyCallStatusChangeStatus,

   273 														 callStatus,

   274 														 expectedCallStatus,

   275 														 expectedStatus);

   276 														 

   277 	mobileLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);													

   278 	expectedLineStatus = RCall::EStatusIdle;

   279 	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

   280 														 notifyStatusChangeStatus,

   281 														 lineStatus,

   282 														 expectedLineStatus,

   283 														 expectedStatus);

   284 	*/

   285 														 

   286 	// 3. Set up multimedia mobile data call with bad parameters in TMobileDataCallParamsVx. 

   287 	RMobileCall::TMobileHscsdCallParamsV1 multimediaParams3;

   288 	RMobileCall::TMobileHscsdCallParamsV1Pckg checkParamsPkg3(multimediaParams3);

   289 	

   290 	// valid parameters with invalid iProtocol parameter 

   291 	multimediaParams3.iIdRestrict = RMobileCall::ESendMyId;

   292 	multimediaParams3.iAckTimer = 20;

   293 	multimediaParams3.iMSToModemWindowSize = 2;

   294 	multimediaParams3.iModemToMSWindowSize = 2;	

   295 	multimediaParams3.iProtocol = RMobileCall::EProtocolPstnMultimedia;

   296 	multimediaParams3.iQoS = RMobileCall::EQoSNonTransparent;

   297 	multimediaParams3.iRLPVersion = RMobileCall::ERLPSingleLinkVersion0;

   298 	multimediaParams3.iResequencingPeriod = 1;

   299 	multimediaParams3.iRetransmissionAttempts = 2;

   300 	multimediaParams3.iService = RMobileCall::EServiceDataCircuitSync;

   301 	multimediaParams3.iSpeed = RMobileCall::ESpeed64000;

   302 	multimediaParams3.iUseEdge = EFalse;

   303 	multimediaParams3.iV42bisCodewordsNum = 0;

   304     multimediaParams3.iV42bisMaxStringLength = 0;

   305     multimediaParams3.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   306     multimediaParams.iMaxTimeSlots = 15;

   307 	multimediaParams.iWantedRxTimeSlots = 15;

   308 	multimediaParams.iWantedAiur = RMobileCall::EAiurBpsUnspecified;

   309 	

   310 	// Dial a number that answers. 

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

   312 	// $CTSYProblem: dial returns -18 or -6 depending of selected parametes (protocol)

   313     // EProtocolPstnMultimedia = -6, EProtocolV34 = -18

   314     // All CSD call are currently failing, this is not a CTSY problem because CTSY

   315     // has no control over this issue

   316 	call1.Dial(dialStatus, checkParamsPkg2, number); 

   317 

   318 	// Verify dialling fails. 

   319 	ASSERT_TRUE((dialStatus.Int()!= KErrNone), _L("RCall::Dial did not returned with an error"));

   320 	

   321 	//

   322 	// TEST END

   323 	//

   324 

   325     StartCleanup();

   326 	

   327 	

   328 	// Pop

   329 	// notifyStatusChangeStatus

   330 	// dialStatus

   331 	// hangUpStatus

   332 	// notifyCallStatusChangeStatus

   333 	CleanupStack::PopAndDestroy(4, &notifyStatusChangeStatus);

   334 	

   335 	

   336 	return TestStepResult();

   337 	}

   338 

   339 TPtrC CCTSYIntegrationTestMultimediaCallControl0001::GetTestStepName()

   340 /**

   341  * @return The test step name.

   342  */

   343 	{

   344 	return _L("CCTSYIntegrationTestMultimediaCallControl0001");

   345 	}

   346 

   347 

   348 

   349 CCTSYIntegrationTestMultimediaCallControl0002::CCTSYIntegrationTestMultimediaCallControl0002(CEtelSessionMgr& aEtelSessionMgr)

   350 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

   351 /**

   352  * Constructor.

   353  */

   354 	{

   355 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0002::GetTestStepName());

   356 	}

   357 

   358 CCTSYIntegrationTestMultimediaCallControl0002::~CCTSYIntegrationTestMultimediaCallControl0002()

   359 /**

   360  * Destructor.

   361  */

   362 	{

   363 	}

   364 

   365 TVerdict CCTSYIntegrationTestMultimediaCallControl0002::doTestStepL()

   366 /**

   367  * @SYMTestCaseID BA-CTSY-INT-MMCC-0002

   368  * @SYMFssID BA/CTSY/MMCC-0002

   369  * @SYMTestCaseDesc Ensure a video call can be hung up by originator.

   370  * @SYMTestPriority High

   371  * @SYMTestActions RMobileCall::GetMobileCallInfo, RLine::NotifyStatusChange, RCall::HangUp, RCall::GetCallParams

   372  * @SYMTestExpectedResults Pass - Video call is hung up.

   373  * @SYMTestType CIT

   374  * @SYMTestCaseDependencies live/manual

   375  *

   376 

   377  *

   378  * @return - TVerdict code

   379  */

   380 	{

   381 

   382 	//

   383 	// SET UP

   384 	//

   385 

   386 	

   387 	// Ensure phone is camped on a valid cell. 

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

   389 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   390 

   391 	// Get data line 1. 

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

   393 	

   394 	// Get call 1. 

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

   396 	

   397     // Check current networkmode returns ENetworkModeWcdma

   398 	RMobilePhone::TMobilePhoneNetworkMode mode;

   399 	CHECK_EQUALS_L(phone.GetCurrentMode(mode), KErrNone, _L("RMobilePhone::GetCurrentMode returned with an error"));

   400 	CHECK_EQUALS_L(mode, RMobilePhone::ENetworkModeWcdma, _L("RMobilePhone::GetCurrentMode did not return ENetworkModeWcdma as expected"));

   401 

   402 	//

   403 	// SET UP END

   404 	//

   405 	

   406 	StartTest();

   407 	

   408 	//

   409 	// TEST START

   410 	//

   411 	

   412 	

   413 	// Set up multimedia mobile data call parameters for a multimedia call. 

   414 	RMobileCall::TMobileHscsdCallParamsV1 multimediaParams;

   415 	RMobileCall::TMobileHscsdCallParamsV1Pckg checkParamsPkg(multimediaParams);

   416 	

   417 	// valid parameters 

   418 	multimediaParams.iIdRestrict = RMobileCall::ESendMyId;

   419 	multimediaParams.iAckTimer = 20;

   420 	multimediaParams.iMSToModemWindowSize = 2;

   421 	multimediaParams.iModemToMSWindowSize = 2;	

   422 	multimediaParams.iProtocol = RMobileCall::EProtocolV34;

   423 	multimediaParams.iQoS = RMobileCall::EQoSNonTransparent;

   424 	multimediaParams.iRLPVersion = RMobileCall::ERLPSingleLinkVersion0;

   425 	multimediaParams.iResequencingPeriod = 1;

   426 	multimediaParams.iRetransmissionAttempts = 2;

   427 	multimediaParams.iService = RMobileCall::EServiceDataCircuitAsync;

   428 	multimediaParams.iSpeed = RMobileCall::ESpeed64000;

   429 	multimediaParams.iUseEdge = EFalse;

   430 	multimediaParams.iV42bisCodewordsNum = 0;

   431     multimediaParams.iV42bisMaxStringLength = 0;

   432     multimediaParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

   433 	multimediaParams.iAsymmetry = RMobileCall::EAsymmetryDownlink;

   434 	multimediaParams.iCodings = RMobileCall::KCapsAiurCoding144;

   435 	multimediaParams.iUserInitUpgrade = EFalse;

   436 	multimediaParams.iMaxTimeSlots = 15;

   437 	multimediaParams.iWantedRxTimeSlots = 15;

   438 	multimediaParams.iWantedAiur = RMobileCall::EAiurBpsUnspecified;

   439 

   440     // post a notifier for RLine::NotifyStatusChange

   441 	TCoreEtelRequestStatus<RLine> notifyStatusChangeStatus(mobileLine,&RLine::NotifyStatusChangeCancel);

   442 	CleanupStack::PushL(notifyStatusChangeStatus);

   443 	RCall::TStatus lineStatus;

   444 	mobileLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   445     

   446 	// Dial a number that answers.

   447 	TPtrC number; 

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

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

   450 	CleanupStack::PushL(dialStatus);

   451 

   452     // Failing CSD calls (see $CTSYProblem described below).

   453     // Code can be added in after multimedia calls are working.

   454 

   455 	// $CTSYProblem: dial returns -18 or -6 depending of selected parametes (protocol)

   456     // EProtocolPstnMultimedia = -6, EProtocolV34 = -18

   457     // All CSD call are currently failing, this is not a CTSY problem because CTSY has no control over this issue

   458     /*

   459 	call1.Dial(dialStatus, checkParamsPkg, number); 

   460 	TEST_CHECK_POINT_L(_L("Couldn't dial a call, no point continuing."));

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

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

   463 	

   464 	// Verify line status goes from ringing to connected 

   465 	RCall::TStatus expectedLineStatus = RCall::EStatusRinging;

   466 	const TInt expectedStatus = KErrNone;

   467 	

   468 	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

   469 														 notifyStatusChangeStatus,

   470 														 lineStatus,

   471 														 expectedLineStatus,

   472 														 expectedStatus);			

   473 

   474 	mobileLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   475 	expectedLineStatus = RCall::EStatusConnected;

   476 	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

   477 														 notifyStatusChangeStatus,

   478 														 lineStatus,

   479 														 expectedLineStatus,

   480 														 expectedStatus);

   481 

   482 	// Get call information and verify it is as expected. 

   483 	RMobileCall::TMobileCallInfoV1 mobileCallInfo;

   484 	RMobileCall::TMobileCallInfoV1Pckg callInfoPckg(mobileCallInfo);

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

   486 	ASSERT_TRUE(mobileCallInfo.iCallName.Length() >0, _L("RMobileCall::GetMobileCallInfo returned an invalid callName"));

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

   488 

   489 	// Get call params and verify it is as expected.

   490 	ASSERT_EQUALS(call1.GetCallParams(checkParamsPkg), KErrNone, _L("RCall::GetCallParams returned an error"));

   491 	ASSERT_TRUE(multimediaParams.iSpeed = RMobileCall::ESpeed64000, _L("RCall::GetCallParams returned wrongly RMobileCall::ESpeedUnspecified"));

   492 	ASSERT_TRUE(multimediaParams.iProtocol = RMobileCall::EProtocolPstnMultimedia, _L("TMobileDataCallParamsV1 returns aParams.iProtocol"));

   493 	ASSERT_EQUALS(multimediaParams.iService,  RMobileCall::EServiceDataCircuitAsync, _L("RCall::GetCallParams service was not the same that used in dial"));

   494 	*/

   495 	// Hang up.

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

   497 	CleanupStack::PushL(hangUpStatus);

   498 	/*

   499 	call1.HangUp(hangUpStatus);

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

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

   502 	*/

   503 	

   504 	//

   505 	// TEST END

   506 	//

   507 

   508     StartCleanup();

   509 	

   510 	//notifyStatusChangeStatus

   511 	//dialStatus

   512 	//hangUpStatus

   513 	CleanupStack::PopAndDestroy(3, &notifyStatusChangeStatus);

   514 	

   515 	return TestStepResult();

   516 	}

   517 

   518 TPtrC CCTSYIntegrationTestMultimediaCallControl0002::GetTestStepName()

   519 /**

   520  * @return The test step name.

   521  */

   522 	{

   523 	return _L("CCTSYIntegrationTestMultimediaCallControl0002");

   524 	}

   525 

   526 

   527 

   528 CCTSYIntegrationTestMultimediaCallControl0003::CCTSYIntegrationTestMultimediaCallControl0003(CEtelSessionMgr& aEtelSessionMgr)

   529 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

   530 /**

   531  * Constructor.

   532  */

   533 	{

   534 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0003::GetTestStepName());

   535 	}

   536 

   537 CCTSYIntegrationTestMultimediaCallControl0003::~CCTSYIntegrationTestMultimediaCallControl0003()

   538 /**

   539  * Destructor.

   540  */

   541 	{

   542 	}

   543 

   544 TVerdict CCTSYIntegrationTestMultimediaCallControl0003::doTestStepL()

   545 /**

   546  * @SYMTestCaseID BA-CTSY-INT-MMCC-0003

   547  * @SYMFssID BA/CTSY/MMCC-0003

   548  * @SYMTestCaseDesc Ensure a video call can be hung up by remote party.

   549  * @SYMTestPriority High

   550  * @SYMTestActions RMobileCall::GetMobileCallInfo, RLine::NotifyIncomingCall, RCall::HangUp, RCall::AnswerIncomingCall, RCall::GetCallParams

   551  * @SYMTestExpectedResults Pass - Video call is hung up.

   552  * @SYMTestType CIT

   553  * @SYMTestCaseDependencies live/manual

   554  *

   555 

   556  *

   557  * @return - TVerdict code

   558  */

   559 	{

   560 

   561 	//

   562 	// SET UP

   563 	//

   564 

   565 	

   566 	// Ensure phone is camped on a valid cell. 

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

   568 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   569 	

   570 	// Get data line 1. 

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

   572 	

   573 

   574 	//

   575 	// SET UP END

   576 	//

   577 	

   578 	StartTest();

   579 	

   580 	//

   581 	// TEST START

   582 	//

   583 	

   584 	

   585 	// Make an incoming call to the board. 

   586 	

   587 	// post notifier for RLine::NotifyIncomingCall

   588 	TCoreEtelRequestStatus<RLine> notifyIncomingCallStatus (mobileLine,&RLine::NotifyIncomingCallCancel);

   589 	CleanupStack::PushL(notifyIncomingCallStatus);

   590 	TName name;

   591 	mobileLine.NotifyIncomingCall(notifyIncomingCallStatus,name);	

   592 

   593     // Failing CSD calls (see $CTSYProblem described below).

   594     // Code can be added in after multimedia calls are working.

   595 

   596 	// $CTSYProblem: The line is not notifying tester to answer the incoming call ( notifier never completes). 

   597 	// CTSY does not receive anykind of signal from line about incoming call thus it cannot be answered.

   598     // All CSD call are currently failing, this is not a CTSY problem because CTSY has no control over this issue

   599 

   600 	/*

   601 	// Remote party invokes an incoming video call. 

   602 	DisplayUserInteractionPromptL(_L("You should now dial a multimedia call to this board from some other mobilephone"), ETimeLong);

   603 

   604 	// Check RLine::NotifyIncomingCall completes with valid call name.

   605 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyIncomingCallStatus,ETimeMedium), KErrNone, _L("RLine::NotifyIncomingCall did not complete without error"));

   606 	ASSERT_EQUALS(notifyIncomingCallStatus.Int(), KErrNone, _L("RLine::NotifyIncomingCall set requestStatus to an error"));

   607 	ASSERT_TRUE(name.Length() > 0, _L("RLine::NotifyIncomingCall did not set the name"));

   608 

   609 	// Get call 1.

   610 	TCallId incomingCallId;

   611 	RMobileCall& dataCall = iEtelSessionMgr.GetIncomingCallL(KMainServer, KMainPhone, KDataLine, name, incomingCallId);

   612 	

   613 	// post notifier for RCall::NotifyStatusChange for incoming call

   614 	TCoreEtelRequestStatus<RCall> notifyCallStatusChangeStatus (dataCall, &RCall::NotifyStatusChangeCancel);

   615 	CleanupStack::PushL(notifyCallStatusChangeStatus);

   616 	RCall::TStatus callStatus;

   617 	dataCall.NotifyStatusChange(notifyCallStatusChangeStatus, callStatus);

   618 	

   619 	// Answer incoming call. 

   620 	TCoreEtelRequestStatus<RCall> answerIncomingStatus(dataCall, &RCall::AnswerIncomingCallCancel);

   621 	CleanupStack::PushL(answerIncomingStatus);	

   622 	

   623 	dataCall.AnswerIncomingCall(answerIncomingStatus);

   624 	ASSERT_EQUALS(WaitForRequestWithTimeOut(answerIncomingStatus, ETimeMedium), KErrNone, _L("RMobileCall::AnswerIncomingCall timed-out"));

   625 	ASSERT_EQUALS(answerIncomingStatus.Int(), KErrNone, _L("RMobileCall::AnswerIncomingCall returned with an error"));

   626 	

   627 	// Verify call connected. 

   628 	RCall::TStatus expectedCallStatus = RCall::EStatusConnected;

   629 	

   630 	iCallControlTestHelper.WaitForCallNotifyStatusChange(dataCall,

   631 														 notifyCallStatusChangeStatus,

   632 														 callStatus,

   633 														 expectedCallStatus,

   634 														 KErrNone);

   635 

   636 	// Get call information and verify it is as expected. 

   637 	RMobileCall::TMobileCallInfoV1 mobileCallInfo;

   638 	RMobileCall::TMobileCallInfoV1Pckg callInfoPckg(mobileCallInfo);

   639 	ASSERT_EQUALS(dataCall.GetMobileCallInfo(callInfoPckg), KErrNone, _L("RMobileCall::GetMobileCallInfo returned an error"));

   640 	ASSERT_TRUE(mobileCallInfo.iCallName.Length() >0, _L("RMobileCall::GetMobileCallInfo returned an invalid callName"));

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

   642 

   643 	// Get call params and verify it is as expected. 

   644 	RMobileCall::TMobileDataCallParamsV1 multimediaParams;

   645 	RMobileCall::TMobileCallParamsV1Pckg checkParamsPkg(multimediaParams);

   646 	ASSERT_EQUALS(dataCall.GetCallParams(checkParamsPkg), KErrNone, _L("RCall::GetCallParams returned an error"));

   647 	ASSERT_TRUE(multimediaParams.iSpeed = RMobileCall::ESpeed64000, _L("RCall::GetCallParams returned wrongly RMobileCall::ESpeedUnspecified"));

   648 	ASSERT_TRUE(multimediaParams.iProtocol = RMobileCall::EProtocolPstnMultimedia, _L("TMobileDataCallParamsV1 returns aParams.iProtocol"));

   649 	ASSERT_EQUALS(multimediaParams.iService,  RMobileCall::EServiceDataCircuitAsync, _L("RCall::GetCallParams service was not the same that used in dial"));

   650 	

   651 	// post a notifier for RLine::NotifyStatusChange

   652 	TCoreEtelRequestStatus<RLine> notifyStatusChangeStatus (mobileLine,&RLine::NotifyStatusChangeCancel);

   653 	CleanupStack::PushL(notifyStatusChangeStatus);

   654 	RCall::TStatus lineStatus;

   655 	mobileLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   656 

   657 	// post notify for RCall::NotifyStatusChange

   658 	dataCall.NotifyStatusChange(notifyCallStatusChangeStatus, callStatus);

   659 

   660 	// Hang up. 

   661 	TCoreEtelRequestStatus<RCall> hangUpStatus (dataCall, &RCall::HangUpCancel);	

   662 	CleanupStack::PushL(hangUpStatus);

   663 	dataCall.HangUp(hangUpStatus);

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

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

   666 

   667 	// Verify call and line are idle. 

   668 	expectedCallStatus = RCall::EStatusIdle;

   669 	iCallControlTestHelper.WaitForCallNotifyStatusChange(dataCall,

   670 														 notifyCallStatusChangeStatus,

   671 														 callStatus,

   672 														 expectedCallStatus,

   673 														 KErrNone);

   674 														 

   675 	RCall::TStatus expectedLineStatus = RCall::EStatusIdle;

   676 	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

   677 														 notifyStatusChangeStatus,

   678 														 lineStatus,

   679 														 expectedLineStatus,

   680 														 KErrNone);

   681 	*/

   682 	

   683 	//

   684 	// TEST END

   685 	//

   686 

   687     StartCleanup();

   688 	

   689 	// Pop

   690 	// notifyIncomingCallStatus

   691 	// notifyCallStatusChangeStatus

   692 	// answerIncomingStatus

   693 	// notifyStatusChangeStatus

   694 	// hangUpStatus

   695 	CleanupStack::PopAndDestroy(1, &notifyIncomingCallStatus);

   696 

   697 	return TestStepResult();

   698 	}

   699 

   700 TPtrC CCTSYIntegrationTestMultimediaCallControl0003::GetTestStepName()

   701 /**

   702  * @return The test step name.

   703  */

   704 	{

   705 	return _L("CCTSYIntegrationTestMultimediaCallControl0003");

   706 	}

   707 

   708 

   709 

   710 CCTSYIntegrationTestMultimediaCallControl0004::CCTSYIntegrationTestMultimediaCallControl0004(CEtelSessionMgr& aEtelSessionMgr)

   711 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

   712 /**

   713  * Constructor.

   714  */

   715 	{

   716 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0004::GetTestStepName());

   717 	}

   718 

   719 CCTSYIntegrationTestMultimediaCallControl0004::~CCTSYIntegrationTestMultimediaCallControl0004()

   720 /**

   721  * Destructor.

   722  */

   723 	{

   724 	}

   725 

   726 TVerdict CCTSYIntegrationTestMultimediaCallControl0004::doTestStepL()

   727 /**

   728  * @SYMTestCaseID BA-CTSY-INT-MMCC-0004

   729  * @SYMFssID BA/CTSY/MMCC-0004

   730  * @SYMTestCaseDesc Test hanging up a video call before the line starts ringing.

   731  * @SYMTestPriority High

   732  * @SYMTestActions RCall::DialCancel, RCall::GetStatus, RLine::GetStatus

   733  * @SYMTestExpectedResults Pass - Video call dialling is cancelled.

   734  * @SYMTestType CIT

   735  * @SYMTestCaseDependencies live/manual

   736  *

   737 

   738  *

   739  * @return - TVerdict code

   740  */

   741 	{

   742 

   743 	//

   744 	// SET UP

   745 	//

   746 

   747 	

   748 	// Ensure phone is camped on a valid cell. 

   749 

   750 	// Get data line 1. 

   751 

   752 	// Get call 1. 

   753 

   754 

   755 	//

   756 	// SET UP END

   757 	//

   758 	

   759 	StartTest();

   760 	

   761 	//

   762 	// TEST START

   763 	//

   764 	

   765 	

   766 	// Set up multimedia mobile data call parameters for a multimedia call. 

   767 

   768 	// Dial. 

   769 

   770 	// Cancel dial. 

   771 

   772 	// Verify call and line are idle. 

   773 

   774 	

   775 	//

   776 	// TEST END

   777 	//

   778 

   779     StartCleanup();

   780 	

   781 	// Put any required test clean up here, then remove this comment

   782 	

   783 	return TestStepResult();

   784 	}

   785 

   786 TPtrC CCTSYIntegrationTestMultimediaCallControl0004::GetTestStepName()

   787 /**

   788  * @return The test step name.

   789  */

   790 	{

   791 	return _L("CCTSYIntegrationTestMultimediaCallControl0004");

   792 	}

   793 

   794 

   795 

   796 CCTSYIntegrationTestMultimediaCallControl0005::CCTSYIntegrationTestMultimediaCallControl0005(CEtelSessionMgr& aEtelSessionMgr)

   797 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

   798 /**

   799  * Constructor.

   800  */

   801 	{

   802 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0005::GetTestStepName());

   803 	}

   804 

   805 CCTSYIntegrationTestMultimediaCallControl0005::~CCTSYIntegrationTestMultimediaCallControl0005()

   806 /**

   807  * Destructor.

   808  */

   809 	{

   810 	}

   811 

   812 TVerdict CCTSYIntegrationTestMultimediaCallControl0005::doTestStepL()

   813 /**

   814  * @SYMTestCaseID BA-CTSY-INT-MMCC-0005

   815  * @SYMFssID BA/CTSY/MMCC-0005

   816  * @SYMTestCaseDesc Test hanging up a video call while the line is ringing.

   817  * @SYMTestPriority High

   818  * @SYMTestActions RLine::NotifyStatusChange, RCall::HangUp, RCall::GetStatus, RLine::GetStatus

   819  * @SYMTestExpectedResults Pass - Video call is hung up.

   820  * @SYMTestType CIT

   821  * @SYMTestCaseDependencies live/manual

   822  *

   823 

   824  *

   825  * @return - TVerdict code

   826  */

   827 	{

   828 

   829 	//

   830 	// SET UP

   831 	//

   832 

   833 	

   834 	// Ensure phone is camped on a valid cell. 

   835 

   836 	// Get data line 1. 

   837 

   838 	// Get call 1. 

   839 

   840 

   841 	//

   842 	// SET UP END

   843 	//

   844 	

   845 	StartTest();

   846 	

   847 	//

   848 	// TEST START

   849 	//

   850 	

   851 	

   852 	// Set up multimedia mobile data call parameters for a multimedia call. 

   853 

   854 	// Dial a number that won't answer. 

   855 

   856 	// Verify line goes to ringing. 

   857 

   858 	// Hang up. 

   859 

   860 	

   861 	//

   862 	// TEST END

   863 	//

   864 

   865     StartCleanup();

   866 	

   867 	// Put any required test clean up here, then remove this comment

   868 	

   869 	return TestStepResult();

   870 	}

   871 

   872 TPtrC CCTSYIntegrationTestMultimediaCallControl0005::GetTestStepName()

   873 /**

   874  * @return The test step name.

   875  */

   876 	{

   877 	return _L("CCTSYIntegrationTestMultimediaCallControl0005");

   878 	}

   879 

   880 

   881 

   882 CCTSYIntegrationTestMultimediaCallControl0006::CCTSYIntegrationTestMultimediaCallControl0006(CEtelSessionMgr& aEtelSessionMgr)

   883 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

   884 /**

   885  * Constructor.

   886  */

   887 	{

   888 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0006::GetTestStepName());

   889 	}

   890 

   891 CCTSYIntegrationTestMultimediaCallControl0006::~CCTSYIntegrationTestMultimediaCallControl0006()

   892 /**

   893  * Destructor.

   894  */

   895 	{

   896 	}

   897 

   898 TVerdict CCTSYIntegrationTestMultimediaCallControl0006::doTestStepL()

   899 /**

   900  * @SYMTestCaseID BA-CTSY-INT-MMCC-0006

   901  * @SYMFssID BA/CTSY/MMCC-0006

   902  * @SYMTestCaseDesc Test handling of time out when remote party does not answer the video call.

   903  * @SYMTestPriority High

   904  * @SYMTestActions RLine::NotifyStatusChange

   905  * @SYMTestExpectedResults Pass - Call does not connect.

   906  * @SYMTestType CIT

   907  * @SYMTestCaseDependencies live/manual

   908  *

   909 

   910  *

   911  * @return - TVerdict code

   912  */

   913 	{

   914 

   915 	//

   916 	// SET UP

   917 	//

   918 

   919 	

   920 	// Ensure phone is camped on a valid cell. 

   921 

   922 	// Get data line 1. 

   923 

   924 	// Get call 1. 

   925 

   926 

   927 	//

   928 	// SET UP END

   929 	//

   930 	

   931 	StartTest();

   932 	

   933 	//

   934 	// TEST START

   935 	//

   936 	

   937 	

   938 	// Set up multimedia mobile data call parameters for a multimedia call. 

   939 

   940 	// Dial a number that won't answer. 

   941 

   942 	// Cancel dial. 

   943 

   944 	

   945 	//

   946 	// TEST END

   947 	//

   948 

   949     StartCleanup();

   950 	

   951 	// Put any required test clean up here, then remove this comment

   952 	

   953 	return TestStepResult();

   954 	}

   955 

   956 TPtrC CCTSYIntegrationTestMultimediaCallControl0006::GetTestStepName()

   957 /**

   958  * @return The test step name.

   959  */

   960 	{

   961 	return _L("CCTSYIntegrationTestMultimediaCallControl0006");

   962 	}

   963 

   964 

   965 

   966 CCTSYIntegrationTestMultimediaCallControl0007::CCTSYIntegrationTestMultimediaCallControl0007(CEtelSessionMgr& aEtelSessionMgr)

   967 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

   968 /**

   969  * Constructor.

   970  */

   971 	{

   972 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0007::GetTestStepName());

   973 	}

   974 

   975 CCTSYIntegrationTestMultimediaCallControl0007::~CCTSYIntegrationTestMultimediaCallControl0007()

   976 /**

   977  * Destructor.

   978  */

   979 	{

   980 	}

   981 

   982 TVerdict CCTSYIntegrationTestMultimediaCallControl0007::doTestStepL()

   983 /**

   984  * @SYMTestCaseID BA-CTSY-INT-MMCC-0007

   985  * @SYMFssID BA/CTSY/MMCC-0007

   986  * @SYMTestCaseDesc Test handling of video call when called party is busy.

   987  * @SYMTestPriority High

   988  * @SYMTestActions 

   989  * @SYMTestExpectedResults Pass - Error returned when dialling busy number.

   990  * @SYMTestType CIT

   991  * @SYMTestCaseDependencies live/manual

   992  *

   993 

   994  *

   995  * @return - TVerdict code

   996  */

   997 	{

   998 

   999 	//

  1000 	// SET UP

  1001 	//

  1002 

  1003 	

  1004 	// Ensure phone is camped on a valid cell. 

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

  1006 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

  1007 

  1008 	// Get data line 1. 

  1009 	RMobileLine& line = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KDataLine);

  1010 

  1011 	// Get call 1.

  1012 	RMobileCall& call = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KDataLine, KCall1); 

  1013 

  1014 	// Ensure call waiting is deactivated. 

  1015 	RMobilePhone::TMobileService mobileService = RMobilePhone::EAllServices;

  1016 	RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate;

  1017 	TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(phone, EMobilePhoneSetCallWaitingStatus);

  1018 	CleanupStack::PushL(mobilePhoneSetCallWaitingStatus);

  1019 	phone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction);

  1020 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallWaitingStatus timed-out"))

  1021 	CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, _L("RMobilePhone::SetCallWaitingStatus returned with an error"))		

  1022 

  1023 

  1024 	//

  1025 	// SET UP END

  1026 	//

  1027 	

  1028 	StartTest();

  1029 	

  1030 	//

  1031 	// TEST START

  1032 	//

  1033 	

  1034 	

  1035 	// Set up multimedia mobile data call parameters for a multimedia call. 

  1036 	RMobileCall::TMobileHscsdCallParamsV1 mobileHscsdCallParams;

  1037 	RMobileCall::TMobileHscsdCallParamsV1Pckg mobileHscsdCallParamsPckg(mobileHscsdCallParams);

  1038 	mobileHscsdCallParams.iIdRestrict = RMobileCall::ESendMyId;

  1039 	mobileHscsdCallParams.iAckTimer = 20;

  1040 	mobileHscsdCallParams.iMSToModemWindowSize = 2;

  1041 	mobileHscsdCallParams.iModemToMSWindowSize = 2;	

  1042 	mobileHscsdCallParams.iProtocol = RMobileCall::EProtocolPstnMultimedia;

  1043 	mobileHscsdCallParams.iQoS = RMobileCall::EQoSNonTransparent;

  1044 	mobileHscsdCallParams.iRLPVersion = RMobileCall::ERLPSingleLinkVersion0;

  1045 	mobileHscsdCallParams.iResequencingPeriod = 1;

  1046 	mobileHscsdCallParams.iRetransmissionAttempts = 2;

  1047 	mobileHscsdCallParams.iService = RMobileCall::EServiceDataCircuitAsync;

  1048 	mobileHscsdCallParams.iSpeed = RMobileCall::ESpeed64000;

  1049 	mobileHscsdCallParams.iUseEdge = EFalse;

  1050 	mobileHscsdCallParams.iV42bisCodewordsNum = 0;

  1051     mobileHscsdCallParams.iV42bisMaxStringLength = 0;

  1052     mobileHscsdCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;

  1053 	mobileHscsdCallParams.iAsymmetry = RMobileCall::EAsymmetryDownlink;

  1054 	mobileHscsdCallParams.iCodings = RMobileCall::KCapsAiurCoding144;

  1055 	mobileHscsdCallParams.iUserInitUpgrade = EFalse;

  1056 	mobileHscsdCallParams.iMaxTimeSlots = 15;

  1057 	mobileHscsdCallParams.iWantedRxTimeSlots = 15;

  1058 	mobileHscsdCallParams.iWantedAiur = RMobileCall::EAiurBpsUnspecified;

  1059 	

  1060 	// Dial a number which is engaged. 

  1061 	DisplayUserInteractionPromptL(_L("Please be sure that DataNumber1 is currently engaged"), ETimeMedium);

  1062 	TPtrC number; 

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

  1064 	DEBUG_PRINTF2(_L("Board is now dialling: %S"), &number);

  1065 	TCoreEtelRequestStatus<RMobileCall> dialStatus(call, &RMobileCall::DialCancel);

  1066 	CleanupStack::PushL(dialStatus);

  1067 

  1068     // Failing CSD calls (see $CTSYProblem described below).

  1069     // Code can be added in after multimedia calls are working.

  1070 

  1071 	// $CTSYProblem: dial returns -18 or -6 depending of selected parametes (protocol)

  1072     // EProtocolPstnMultimedia = -6, EProtocolV34 = -18

  1073     // All CSD call are currently failing, this is not a CTSY problem because CTSY has no control over this issue

  1074     /*

  1075 	call.Dial(dialStatus, mobileHscsdCallParamsPckg, number); 

  1076 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));

  1077 

  1078 	// Verify dial fails. 

  1079 	ASSERT_TRUE(dialStatus.Int() != KErrNone, _L("RMobileCall::Dial did not return error as expected"));

  1080 	*/

  1081 	//

  1082 	// TEST END

  1083 	//

  1084 

  1085     StartCleanup();

  1086 	

  1087 	// Pop

  1088     // mobilePhoneSetCallWaitingStatus

  1089     // dialStatus

  1090     CleanupStack::PopAndDestroy(2, &mobilePhoneSetCallWaitingStatus);

  1091 		

  1092 	return TestStepResult();

  1093 	}

  1094 

  1095 TPtrC CCTSYIntegrationTestMultimediaCallControl0007::GetTestStepName()

  1096 /**

  1097  * @return The test step name.

  1098  */

  1099 	{

  1100 	return _L("CCTSYIntegrationTestMultimediaCallControl0007");

  1101 	}

  1102 

  1103 

  1104 

  1105 CCTSYIntegrationTestMultimediaCallControl0008::CCTSYIntegrationTestMultimediaCallControl0008(CEtelSessionMgr& aEtelSessionMgr)

  1106 	: CCTSYIntegrationTestMultimediaCallControlBase(aEtelSessionMgr)

  1107 /**

  1108  * Constructor.

  1109  */

  1110 	{

  1111 	SetTestStepName(CCTSYIntegrationTestMultimediaCallControl0008::GetTestStepName());

  1112 	}

  1113 

  1114 CCTSYIntegrationTestMultimediaCallControl0008::~CCTSYIntegrationTestMultimediaCallControl0008()

  1115 /**

  1116  * Destructor.

  1117  */

  1118 	{

  1119 	}

  1120 

  1121 TVerdict CCTSYIntegrationTestMultimediaCallControl0008::doTestStepL()

  1122 /**

  1123  * @SYMTestCaseID BA-CTSY-INT-MMCC-0008

  1124  * @SYMFssID BA/CTSY/MMCC-0008

  1125  * @SYMTestCaseDesc Test making a video call after temporary deactivation of CLIR.

  1126  * @SYMTestPriority High

  1127  * @SYMTestActions RLine::NotifyStatusChange, RMobilePhone::SetIdentityServiceStatus, RMobilePhone::NotifyIdentityServiceStatus

  1128  * @SYMTestExpectedResults Pass - Caller ID retrieved when CLIR deactivated.

  1129  * @SYMTestType CIT

  1130  * @SYMTestCaseDependencies live/manual

  1131  *

  1132 

  1133  *

  1134  * @return - TVerdict code