1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 /**

    21  * Test step definitions for the CallControl functional unit.

    22  * @internalTechnology

    23  */

    24 

    25 #include "cctsyintegrationtestcallcontrol.h"

    26 #include "cetelsessionmgr.h"

    27 #include "cctsyinidata.h"

    28 #include "tcallcontroltsytesthelper.h"

    29 #include <pcktcs.h>

    30 #include "rpsasciirqstdefs.h"

    31 #include "rpsmaster.h"

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

    33 #include "rpsasciirqstdefs.h"

    34 #include "rpsmaster.h"

    35 

    36 	

    37 CCTSYIntegrationTestCallControlBase::CCTSYIntegrationTestCallControlBase(CEtelSessionMgr& aEtelSessionMgr)

    38 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iCallControlTestHelper(*this), iNetworkTestHelper(*this), iPacketServiceTestHelper(*this)

    39 /**

    40  * Constructor

    41  */

    42 	{

    43 	}

    44 

    45 CCTSYIntegrationTestCallControlBase::~CCTSYIntegrationTestCallControlBase()

    46 /*

    47  * Destructor

    48  */

    49 	{

    50 	}

    51 	

    52 CCTSYIntegrationTestCallControl0001::CCTSYIntegrationTestCallControl0001(CEtelSessionMgr& aEtelSessionMgr)

    53 	: CCTSYIntegrationTestCallControlBase(aEtelSessionMgr)

    54 /**

    55  * Constructor.

    56  */

    57 	{

    58 	SetTestStepName(CCTSYIntegrationTestCallControl0001::GetTestStepName());

    59 	}

    60 

    61 CCTSYIntegrationTestCallControl0001::~CCTSYIntegrationTestCallControl0001()

    62 /**

    63  * Destructor.

    64  */

    65 	{

    66 	}

    67 	

    68 	

    69 TVerdict CCTSYIntegrationTestCallControl0001::doTestStepL()

    70 /**

    71  * @SYMTestCaseID BA-CTSY-INT-CCON-0001

    72  * @SYMFssID BA/CTSY/CCON-0001

    73  * @SYMTestCaseDesc Make an outgoing voice call that connects

    74  * @SYMTestPriority High

    75  * @SYMTestActions RPhone::EnumerateLines, RCall::Dial

    76  * @SYMTestExpectedResults Pass - MO call connects.  Phone status updates correctly.

    77  * @SYMTestType CIT

    78  * @SYMTestCaseDependencies live/automatic

    79  *

    80  * Reason for test: Verify change in call state is reflected in RPhone.

    81  *

    82  * @return - TVerdict code

    83  */

    84 	{

    85 

    86 	////////////////////////////////////////////////////////////////

    87 	// SET UP

    88 	////////////////////////////////////////////////////////////////

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

    90 	

    91 	// Get Voice line 1 

    92 	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

    93 

    94 	// Get call 1 

    95 	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);

    96 		

    97 	// Check phone supports KCapsVoice

    98 	RLine::TCaps lineCaps; 

    99 	CHECK_EQUALS_L(voiceLine.GetCaps(lineCaps), KErrNone, 

   100 			_L("RMobileLine::GetCaps returned an error"));

   101 	CHECK_BITS_SET_L(lineCaps.iFlags, RLine::KCapsVoice, KNoUnwantedBits, 

   102 			_L("RLine::GetCaps returned wrong caps"));

   103 	

   104 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

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

   106 	

   107 	////////////////////////////////////////////////////////////////

   108 	// SET UP END

   109 	////////////////////////////////////////////////////////////////

   110 	

   111 	StartTest();

   112 	

   113 	////////////////////////////////////////////////////////////////

   114 	// TEST START

   115 	////////////////////////////////////////////////////////////////

   116 	

   117 	

   118 	// Check RPhone::EnumerateLines returns 4 (CTSY hard-coded value)

   119 	

   120 	TInt count = 0;

   121 	ASSERT_EQUALS(phone.EnumerateLines(count), KErrNone, 

   122 			_L("RPhone::EnumerateLines did returned an error"));

   123 	ASSERT_EQUALS(count, 4,  

   124 			_L("RPhone::EnumerateLines did not return a count of four"));

   125 	

   126 	// Check RPhone::GetLineInfo returns iStatus of EStatusIdle

   127 	RPhone::TLineInfo lineInfo;

   128 	TInt dataLineIndex=0;

   129 	ASSERT_EQUALS(phone.GetLineInfo(dataLineIndex, lineInfo), KErrNone,

   130 			_L("RPhone::GetLineInfo returned an error"));

   131 	ASSERT_EQUALS(lineInfo.iStatus, RCall::EStatusIdle, 

   132 			_L("RPhone::GetLineInfo wrong iStatus, should be EStatusIdle"));

   133 	

   134 	// Check RPhone::GetLineInfo returns iLineCapsFlags of KCapsVoice

   135 	ASSERT_BITS_SET(lineInfo.iLineCapsFlags, RLine::KCapsVoice, KNoUnwantedBits, 

   136 			_L("RPhone::GetLineInfo returned wrong caps"));	

   137 

   138 	// Check RPhone::GetLineInfo returns a valid line name

   139 	ASSERT_TRUE(lineInfo.iName.Length() >0,  

   140 			_L("RPhone::GetLineInfo wrong call name"));

   141 	

   142 	// Dial voice number that answers. 

   143 	TPtrC number; 

   144 	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse,			  

   145 			_L("CTestStep::GetStringFromConfig did not complete as expected"));

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

   147 	CleanupStack::PushL(dialStatus);

   148 	call1.Dial(dialStatus, number); 

   149 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

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

   151 	ASSERT_EQUALS(dialStatus.Int(), KErrNone,  

   152 			_L("RCall::Dial returned with an error"));

   153 	

   154 	// Check RPhone::GetLineInfo returns iStatus of EStatusConnected

   155 	ASSERT_EQUALS(phone.GetLineInfo(dataLineIndex, lineInfo), KErrNone,  

   156 			_L("RPhone::GetLineInfo returned an error"));

   157 	ASSERT_EQUALS(lineInfo.iStatus, RCall::EStatusConnected, 

   158 			_L("RPhone::GetLineInfo wrong iStatus, should be EStatusConnected"));

   159 

   160 	// Check RPhone::GetLineInfo returns iLineCapsFlags of KCapsVoice	

   161 	ASSERT_BITS_SET(lineInfo.iLineCapsFlags, RLine::KCapsVoice, KNoUnwantedBits, 

   162 			_L("RPhone::GetLineInfo returned wrong caps"));	

   163 

   164 	// Check RPhone::GetLineInfo returns a valid line name

   165 	ASSERT_TRUE(lineInfo.iName.Length() >0,  

   166 			_L("RPhone::GetLineInfo wrong call name"));

   167 

   168 	////////////////////////////////////////////////////////////////

   169 	// TEST END

   170 	////////////////////////////////////////////////////////////////

   171 

   172     StartCleanup();

   173 

   174     // hang up the active call

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

   176 	CleanupStack::PushL(hangUpStatus);

   177 	call1.HangUp(hangUpStatus);

   178 	WaitForRequestWithTimeOut(hangUpStatus, ETimeMedium);	

   179 	

   180 

   181 	CleanupStack::PopAndDestroy(2,&dialStatus);

   182 	

   183 	return TestStepResult();

   184 	}

   185 

   186 TPtrC CCTSYIntegrationTestCallControl0001::GetTestStepName()

   187 /**

   188  * @return The test step name.

   189  */

   190 	{

   191 	return  _L("CCTSYIntegrationTestCallControl0001");

   192 	}

   193 

   194 

   195 

   196 CCTSYIntegrationTestCallControl0002::CCTSYIntegrationTestCallControl0002(CEtelSessionMgr& aEtelSessionMgr)

   197 	: CCTSYIntegrationTestCallControlBase(aEtelSessionMgr)

   198 /**

   199  * Constructor.

   200  */

   201 	{

   202 	SetTestStepName(CCTSYIntegrationTestCallControl0002::GetTestStepName());

   203 	}

   204 

   205 CCTSYIntegrationTestCallControl0002::~CCTSYIntegrationTestCallControl0002()

   206 /**

   207  * Destructor.

   208  */

   209 	{

   210 	}

   211 

   212 TVerdict CCTSYIntegrationTestCallControl0002::doTestStepL()

   213 /**

   214  * @SYMTestCaseID BA-CTSY-INT-CCON-0002

   215  * @SYMFssID BA/CTSY/CCON-0002

   216  * @SYMTestCaseDesc Make an outgoing voice call that connects

   217  * @SYMTestPriority High

   218  * @SYMTestActions RLine::NotifyStatusChange, RLine::GetStatus, RMobileLine::NotifyMobileLineStatusChange, RMobileLine::GetMobileLineStatus, RLine::GetInfo, RLine::GetCallInfo, RLine::EnumerateCall

   219  * @SYMTestExpectedResults Pass - Mo call connects.  Line status updates corectly.

   220  * @SYMTestType CIT

   221  * @SYMTestCaseDependencies live/automatic

   222  *

   223  * Reason for test: Verify change in call state is reflected in RLine and RMobileLine

   224  *

   225  * @return - TVerdict code

   226  */

   227 	{

   228 

   229 	////////////////////////////////////////////////////////////////

   230 	// SET UP

   231 	////////////////////////////////////////////////////////////////

   232 

   233 	// Get phone

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

   235 		

   236 	// Check phone supports KCapsVoice

   237 	// Get Voice line 1 

   238 	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

   239 

   240 	// Get call 1 

   241 	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);

   242 

   243 	// Check GetCaps returns iLineCapsFlags of KCapsVoice 

   244 	RLine::TCaps lineCaps; 

   245 	CHECK_EQUALS_L(voiceLine.GetCaps(lineCaps), KErrNone,  

   246 			_L("RMobileLine::GetCaps returned an error"));

   247 	CHECK_BITS_SET_L(lineCaps.iFlags, RLine::KCapsVoice, KNoUnwantedBits,  

   248 			_L("RLine::GetCaps returned wrong caps"));

   249 	

   250 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

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

   252 	

   253 	////////////////////////////////////////////////////////////////

   254 	// SET UP END

   255 	////////////////////////////////////////////////////////////////

   256 	

   257 	StartTest();

   258 	

   259 	////////////////////////////////////////////////////////////////

   260 	// TEST START

   261 	////////////////////////////////////////////////////////////////

   262 	

   263 	

   264 	// ===  Check line caps ===

   265 

   266 	// Check RLine::GetCaps supports caps in set of KCapsVoice.

   267 	ASSERT_EQUALS(voiceLine.GetCaps(lineCaps), KErrNone,  

   268 			_L("RMobileLine::GetCaps returned an error"));

   269 	ASSERT_BITS_SET(lineCaps.iFlags, RLine::KCapsVoice, KNoUnwantedBits, 

   270 			_L("RLine::GetCaps returned wrong caps"));

   271 

   272 	// ===  Check line status ===

   273 

   274 	// Check RLine::GetStatus returns EStatusIdle.

   275 	RCall::TStatus callStatus;

   276 	ASSERT_EQUALS(voiceLine.GetStatus(callStatus), KErrNone,  

   277 			_L("RLine::GetStatus returned an error"));

   278 	ASSERT_EQUALS(callStatus, RCall::EStatusIdle, 

   279 			_L("RLine::GetStatus wrong iStatus, should be EStatusIdle"));

   280 

   281 	// Check RMobileLine::GetMobileLineStatus returns EStatusIdle.

   282 	RMobileCall::TMobileCallStatus lineStatus;

   283 	ASSERT_EQUALS(voiceLine.GetMobileLineStatus(lineStatus), KErrNone, 

   284 			_L("RMobileLine::GetMobileLineStatus returned an error"));

   285 	ASSERT_EQUALS(lineStatus, RMobileCall::EStatusIdle,

   286 			_L("RMobileLine::GetMobileLineStatus did not return EStatusIdle as expected"));

   287 

   288 	// ===  Check line info ===

   289 

   290 	// Check RLine::GetCallInfo returns valid name.

   291 	// Check RLine::GetCallInfo returns caps in set of KCapsVoice | KCapsDial.

   292 	// Check RLine::GetCallInfo returns status of EStatusIdle.

   293 	RLine::TCallInfo callInfo;

   294 	TInt dataLineIndex=0;

   295 	ASSERT_EQUALS(voiceLine.GetCallInfo(dataLineIndex, callInfo), KErrNone, 

   296 			_L("RLine::GetCallInfo returned an error"));

   297 	ASSERT_TRUE(callInfo.iCallName.Length() >0, 

   298 			_L("RLine::GetCallInfo returned an invalid  name"));

   299 	ASSERT_BITS_SET(callInfo.iCallCapsFlags, RCall::KCapsVoice | RCall::KCapsDial, KNoUnwantedBits , 

   300 			_L("RLine::GetCallInfo returned wrong caps"));	

   301 	ASSERT_EQUALS(callInfo.iStatus, RCall::EStatusIdle, 

   302 			_L("RLine::GetCallInfo wrong iStatus, should be EStatusIdle"));

   303 	

   304 	// Check RLine::GetInfo returns status of EStatusIdle.

   305 	RLine::TLineInfo lineInfo;

   306 	ASSERT_EQUALS(voiceLine.GetInfo(lineInfo),KErrNone, 

   307 			_L("RLine::GetInfo returned an error")); 

   308 	ASSERT_EQUALS(lineInfo.iStatus, RCall::EStatusIdle,

   309 			 _L("RLine::GetInfo did not return EStatusIdle"));

   310 

   311 	// Check RLine::EnumerateCall returns aCount of 4

   312 	TInt count = 0;

   313 	ASSERT_EQUALS(phone.EnumerateLines(count), KErrNone, 

   314 			_L("RPhone::EnumerateLines did returned an error"));

   315 	ASSERT_EQUALS(count, 4,  

   316 			_L("RPhone::EnumerateLines did not return a count of four"));

   317 

   318 	// post notifier for RLine::NotifyStatusChange

   319 	TCoreEtelRequestStatus<RLine> notifyStatusChangeStatus (voiceLine,&RLine::NotifyStatusChangeCancel);

   320 	CleanupStack::PushL(notifyStatusChangeStatus);

   321 	voiceLine.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   322 

   323 	// post a notifier for RMobileLine::NotifyMobileLineStatusChange

   324 	RMobileCall::TMobileCallStatus mobileCallStatus;

   325 	TExtEtelRequestStatus notifyMobileLineChangeStatus(voiceLine, EMobileLineNotifyMobileLineStatusChange);

   326 	CleanupStack::PushL(notifyMobileLineChangeStatus);

   327 	voiceLine.NotifyMobileLineStatusChange(notifyMobileLineChangeStatus, mobileCallStatus);

   328 

   329 	// Dial a voice number that answers. 

   330 	TPtrC number; 

   331 	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse,			  

   332 			_L("CTestStep::GetStringFromConfig did not complete as expected"));

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

   334 	CleanupStack::PushL(dialStatus);

   335 	call1.Dial(dialStatus, number); 

   336 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

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

   338 	ASSERT_EQUALS(dialStatus.Int(), KErrNone,  

   339 			_L("RCall::Dial returned with an error"));

   340 		

   341 	// ===  Check line status ===

   342 

   343 	// Check RLine::NotifyStatusChange completes with EStatusDialling ->

   344 	TInt expectedStatus = KErrNone;  

   345 	RCall::TStatus expectedCallStatus = RCall::EStatusDialling;

   346 	iCallControlTestHelper.WaitForLineNotifyStatusChange(voiceLine,

   347 														 notifyStatusChangeStatus,

   348 														 callStatus,

   349 														 expectedCallStatus,

   350 														 expectedStatus);

   351 

   352 	// Check RLine::NotifyStatusChange completes with EStatusConnecting ->

   353 	expectedCallStatus = RCall::EStatusConnecting;	

   354 	voiceLine.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   355 	iCallControlTestHelper.WaitForLineNotifyStatusChange(voiceLine,

   356 														 notifyStatusChangeStatus,

   357 														 callStatus,

   358 														 expectedCallStatus,

   359 														 expectedStatus);

   360 														 															 

   361 	// Check RLine::NotifyStatusChange completes with EStatusConnected.

   362 	expectedCallStatus = RCall::EStatusConnected;

   363 	voiceLine.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   364 	iCallControlTestHelper.WaitForLineNotifyStatusChange(voiceLine,

   365 														 notifyStatusChangeStatus,

   366 														 callStatus,

   367 														 expectedCallStatus,

   368 														 expectedStatus);

   369 														 

   370 	// Check RLine::GetStatus returns EStatusConnected

   371 	ASSERT_EQUALS(voiceLine.GetStatus(callStatus), KErrNone, 

   372 			_L("RLine::GetStatus returned an error"));

   373 	ASSERT_EQUALS(callStatus, RCall::EStatusConnected, 

   374 			_L("RLine::GetStatus did not return EStatusConnected as expected"));

   375 	

   376 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDialling ->

   377 	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDialling;

   378 	iCallControlTestHelper.WaitForMobileLineNotifyMobileLineStatusChange(voiceLine,

   379 																		notifyMobileLineChangeStatus,

   380 																		mobileCallStatus,

   381 																		expectedMobileCallStatus,

   382 																		expectedStatus);

   383 																		

   384 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusConnecting ->

   385 	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

   386 	voiceLine.NotifyMobileLineStatusChange(notifyMobileLineChangeStatus, mobileCallStatus);

   387 	iCallControlTestHelper.WaitForMobileLineNotifyMobileLineStatusChange(voiceLine,

   388 																		notifyMobileLineChangeStatus,

   389 																		mobileCallStatus,

   390 																		expectedMobileCallStatus,

   391 																		expectedStatus);

   392 

   393 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusConnected.																		

   394 	expectedMobileCallStatus = RMobileCall::EStatusConnected;

   395 	voiceLine.NotifyMobileLineStatusChange(notifyMobileLineChangeStatus, mobileCallStatus);

   396 	iCallControlTestHelper.WaitForMobileLineNotifyMobileLineStatusChange(voiceLine,

   397 																		notifyMobileLineChangeStatus,

   398 																		mobileCallStatus,

   399 																		expectedMobileCallStatus,

   400 																		expectedStatus);

   401 																																					

   402 	

   403 	// Check RMobileLine::GetMobileLineStatus returns EStatusConnected

   404 	ASSERT_EQUALS(voiceLine.GetMobileLineStatus(mobileCallStatus), KErrNone, 

   405 			_L("RMobileLine::GetMobileLineStatus returned an error"));

   406 	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusConnected, 

   407 			_L("RMobileLine::GetMobileLineStatus did not set line status to EStatusConnected"));

   408 	

   409 	

   410 	// ===  Check line info ===

   411 

   412 	// Check RLine::GetCallInfo returns valid name.

   413 	// Check RLine::GetCallInfo returns caps in set of KCapsHangUp.

   414 	// Check RLine::GetCallInfo returns status of EStatusConnected.

   415 	ASSERT_EQUALS(voiceLine.GetCallInfo(dataLineIndex, callInfo), KErrNone,  

   416 			_L("RLine::GetCallInfo returned an error"));

   417 	ASSERT_TRUE(callInfo.iCallName.Length() >0,  

   418 			_L("RLine::GetCallInfo returned an invalid  name"));

   419 	ASSERT_BITS_SET(callInfo.iCallCapsFlags, RCall::KCapsHangUp, KNoUnwantedBits,  

   420 			_L("RLine::GetCallInfo returned wrong caps"));	

   421 	ASSERT_EQUALS(callInfo.iStatus, RCall::EStatusConnected,  

   422 			_L("RLine::GetCallInfo wrong iStatus, should be EStatusConnected"));

   423 

   424 	// Check RLine::GetInfo returns status of EStatusConnected.

   425 	ASSERT_EQUALS(voiceLine.GetInfo(lineInfo), KErrNone,  

   426 			_L("RLine::GetInfo returned an error")); 

   427 	ASSERT_EQUALS(lineInfo.iStatus, RCall::EStatusConnected, 

   428 			_L("RLine::GetInfo did not return EStatusConnected"));

   429 

   430 	

   431 	////////////////////////////////////////////////////////////////

   432 	// TEST END

   433 	////////////////////////////////////////////////////////////////

   434 

   435     StartCleanup();

   436     

   437     // hang up the active call

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

   439 	CleanupStack::PushL(hangUpStatus);

   440 	call1.HangUp(hangUpStatus);

   441 	WaitForRequestWithTimeOut(hangUpStatus, ETimeMedium);	

   442 	

   443 	// Pop 

   444 	// notifyStatusChangeStatus

   445 	// notifyMobileLineChangeStatus

   446 	// dialStatus

   447 	// hangUpStatus

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

   449 	

   450 	return TestStepResult();

   451 	}

   452 

   453 TPtrC CCTSYIntegrationTestCallControl0002::GetTestStepName()

   454 /**

   455  * @return The test step name.

   456  */

   457 	{

   458 	return 	_L("CCTSYIntegrationTestCallControl0002");

   459 	}

   460 

   461 

   462 

   463 CCTSYIntegrationTestCallControl0003::CCTSYIntegrationTestCallControl0003(CEtelSessionMgr& aEtelSessionMgr)

   464 	: CCTSYIntegrationTestCallControlBase(aEtelSessionMgr)

   465 /**

   466  * Constructor.

   467  */

   468 	{

   469 	SetTestStepName(CCTSYIntegrationTestCallControl0003::GetTestStepName());

   470 	}

   471 

   472 CCTSYIntegrationTestCallControl0003::~CCTSYIntegrationTestCallControl0003()

   473 /**

   474  * Destructor.

   475  */

   476 	{

   477 	}

   478 

   479 TVerdict CCTSYIntegrationTestCallControl0003::doTestStepL()

   480 /**

   481  * @SYMTestCaseID BA-CTSY-INT-CCON-0003

   482  * @SYMFssID BA/CTSY/CCON-0003

   483  * @SYMTestCaseDesc Make an outgoing voice call that connects

   484  * @SYMTestPriority High

   485  * @SYMTestActions RCall::GetInfo, RCall::GetStatus, RCall::NotifyCapsChange, RCall::NotifyStatusChange, RMobileCall::GetMobileCallCaps, RMobileCall::GetMobileCallInfo, RMobileCall::GetMobileCallStatus, RMobileCall::NotifyMobileCallCapsChange, RMobileCall::NotifyMobileCallStatusChange

   486  * @SYMTestExpectedResults Pass - Mo call connects.  Call status updates correctly.

   487  * @SYMTestType CIT

   488  * @SYMTestCaseDependencies live/automatic

   489  *

   490  * Reason for test: Verify change in call state is reflected in RCall and RMobileCall.

   491  *

   492  * @return - TVerdict code

   493  */

   494 	{

   495 

   496 	////////////////////////////////////////////////////////////////

   497 	// SET UP

   498 	////////////////////////////////////////////////////////////////

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

   500 	

   501 	// Check phone supports KCapsVoice

   502 	// Get Voice line 1 

   503 	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

   504 

   505 	// Get call 1 

   506 	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);

   507 

   508 	RLine::TCaps lineCaps; 

   509 	CHECK_EQUALS_L(voiceLine.GetCaps(lineCaps), KErrNone,  

   510 			_L("RMobileLine::GetCaps returned an error"));

   511 	CHECK_BITS_SET_L(lineCaps.iFlags, RLine::KCapsVoice, KNoUnwantedBits,  

   512 			_L("RLine::GetCaps returned wrong caps"));

   513 

   514 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

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

   516 

   517 	////////////////////////////////////////////////////////////////

   518 	// SET UP END

   519 	////////////////////////////////////////////////////////////////

   520 	

   521 	StartTest();

   522 	

   523 	////////////////////////////////////////////////////////////////

   524 	// TEST START

   525 	////////////////////////////////////////////////////////////////

   526 	

   527 	

   528 	// ===  Check call caps ===

   529 

   530 	// Check RCall::GetCaps supports KCapsDial | KCapsVoice.

   531 	RCall::TCaps callCaps;

   532 	TUint32 wantedCaps = RCall::KCapsDial | RCall::KCapsVoice;

   533 	ASSERT_EQUALS(call1.GetCaps(callCaps),KErrNone,  

   534 			_L("RCall::GetCaps returned an error"));

   535 	ASSERT_BITS_SET(callCaps.iFlags, wantedCaps, KNoUnwantedBits,  

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

   537 

   538 	// Check RMobileCall::GetMobileCallCaps returns iCallControlCaps in set of KCapsVoice | KCapsDial.

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

   540 	TUint32 wantedCallControlCaps = RCall::KCapsDial | RCall::KCapsVoice;

   541 	TUint32 wantedCallEventCaps = 0;

   542 	RMobileCall::TMobileCallCapsV1 mobileCallCaps;

   543 	RMobileCall::TMobileCallCapsV1Pckg capsPckg(mobileCallCaps);

   544 	ASSERT_EQUALS(call1.GetMobileCallCaps(capsPckg), KErrNone,   

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

   546 	ASSERT_BITS_SET(mobileCallCaps.iCallControlCaps, wantedCallControlCaps, KNoUnwantedBits,   

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

   548 	ASSERT_BITS_SET(mobileCallCaps.iCallEventCaps, wantedCallEventCaps, KNoUnwantedBits,   

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

   550 

   551 	// ===  Check call status ===

   552 

   553 	// Check RCall::GetStatus returns EStatusIdle.

   554 	RCall::TStatus callStatus;

   555 	ASSERT_EQUALS(call1.GetStatus(callStatus), KErrNone,  

   556 			_L("RCall::GetStatus returned an Error"));

   557 	ASSERT_EQUALS(callStatus, RCall::EStatusIdle,  

   558 			_L("RCall::GetStatus did not return EStatusIdle"));

   559 	

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

   561 	RMobileCall::TMobileCallStatus mobileCallStatus;

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

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

   564 	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusIdle,    

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

   566 	

   567 	// ===  Check call info ===

   568 

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

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

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

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

   573 	RCall::TCallInfo callInfo;

   574 	ASSERT_EQUALS(call1.GetInfo(callInfo), KErrNone,  

   575 			_L("RCall::GetInfo returned an error"));

   576 	ASSERT_TRUE(callInfo.iCallName.Length() >0,  

   577 			_L("RCall::GetInfo returned an invalid  name"));

   578 	ASSERT_TRUE(callInfo.iLineName.Length() >0,  

   579 			_L("RCall::GetInfo returned an invalid  Line name"));

   580 	ASSERT_EQUALS(callInfo.iStatus, RCall::EStatusIdle,    

   581 			_L("RCall::GetInfo wrong iStatus, should be EStatusIdle"));

   582 	ASSERT_EQUALS(callInfo.iDuration.Int(), 0,    

   583 			_L("RCall::GetInfo wrong iDuration, should be 0"));

   584 

   585 	// Check RMobileCall::GetMobileCallInfo returns iValid with correct flags for returned parameters set.

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

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

   588 	RMobileCall::TMobileCallInfoV1 mobileCallInfo;

   589 	RMobileCall::TMobileCallInfoV1Pckg callInfoPckg(mobileCallInfo);

   590 	RMobileCall::TMobileCallInfoV1 validCallInfo;

   591 	validCallInfo.iValid = RMobileCall::KCallStartTime;

   592 	ASSERT_EQUALS(call1.GetMobileCallInfo(callInfoPckg), KErrNone,    

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

   594 	ASSERT_BITS_SET(mobileCallInfo.iValid, validCallInfo.iValid,KNoUnwantedBits,    

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

   596 	ASSERT_TRUE(mobileCallInfo.iCallName.Length() >0,    

   597 			_L("RMobileCall::GetMobileCallInfo returned an invalid callName"));

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

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

   600 

   601 	// post notifier for RCall::NotifyCapsChange

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

   603 	CleanupStack::PushL(notifyCapsChangeStatus);

   604 	call1.NotifyCapsChange(notifyCapsChangeStatus,callCaps);

   605 	

   606 	// post notifier for RMobileCall::NotifyMobileCallCapsChange

   607 	TExtEtelRequestStatus notifyMobileCallCapsChangeStatus(call1, EMobileCallNotifyMobileCallCapsChange);

   608 	CleanupStack::PushL(notifyMobileCallCapsChangeStatus);

   609 	call1.NotifyMobileCallCapsChange(notifyMobileCallCapsChangeStatus,capsPckg);

   610 

   611 	// post notifier for RCall::NotifyStatusChange

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

   613 	CleanupStack::PushL(notifyStatusChangeStatus);

   614 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   615 	

   616 	// post notifier for RMobileCall::NotifyMobileCallStatusChange

   617 	TExtEtelRequestStatus notifyMobileCallStatusChangeStatus(call1, EMobileCallNotifyMobileCallStatusChange);

   618 	CleanupStack::PushL(notifyMobileCallStatusChangeStatus);

   619 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   620 

   621 	// Dial a voice number. 

   622 	TPtrC number; 

   623 	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse,			  

   624 			_L("CTestStep::GetStringFromConfig did not complete as expected"));

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

   626 	CleanupStack::PushL(dialStatus);

   627 	call1.Dial(dialStatus, number); 

   628 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

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

   630 	ASSERT_EQUALS(dialStatus.Int(), KErrNone,  

   631 			_L("RCall::Dial returned with an error"));

   632 		

   633 	// ===  Check call caps ===

   634 

   635 	// Check RCall::NotifyCapsChange completes with caps in set of KCapsVoice | KCapsHangUp.

   636 	RCall::TCaps wantedCaps2, unwantedCaps2;

   637 	wantedCaps2.iFlags = RCall::KCapsVoice | RCall::KCapsHangUp;

   638 	unwantedCaps2.iFlags = 0;

   639 	const TInt wantedStatus = KErrNone;

   640 	iCallControlTestHelper.WaitForCallNotifyCapsChange(call1, 

   641 													   notifyCapsChangeStatus,

   642 													   callCaps,

   643 													   wantedCaps2,

   644 													   unwantedCaps2,

   645 													   wantedStatus);

   646 													   

   647 	// Check RCall::GetCaps supports KCapsHangUp | KCapsVoice.

   648 	wantedCaps = RCall::KCapsHangUp | RCall::KCapsVoice;

   649 	ASSERT_EQUALS(call1.GetCaps(callCaps), KErrNone,  

   650 			_L("RCall::GetCaps returned an Error"));

   651 	ASSERT_BITS_SET(callCaps.iFlags, wantedCaps, KNoUnwantedBits,     

   652 			_L("RCall::GetCaps returned unexpected Caps"));

   653 

   654 	

   655 	// Check RMobileCall::NotifyMobileCallCapsChange completes with iCallControlCaps in set of 

   656 	//			KCapsVoice | KCapsHold | KCapsHangUp | KCapsTransfer.

   657 	// Check RMobileCall::NotifyMobileCallCapsChange completes with iCallEventCaps in set of 

   658 	//			KCapsLocalHold | KCapsLocalTransfer | KCapsRemoteHold | KCapsRemoteTerminate | 

   659 	//			KCapsRemoteConferenceCreate.

   660 	RMobileCall::TMobileCallCapsV1 wantedMobileCaps;

   661 	wantedMobileCaps.iCallControlCaps = RMobileCall::KCapsVoice | 

   662 										RMobileCall::KCapsHold | 

   663 										RMobileCall::KCapsHangUp;

   664 										

   665 	wantedMobileCaps.iCallEventCaps = RMobileCall::KCapsLocalHold | 

   666 									  RMobileCall::KCapsLocalTransfer | 

   667 									  RMobileCall::KCapsRemoteHold | 

   668 									  RMobileCall::KCapsRemoteTerminate | 

   669 									  RMobileCall::KCapsRemoteConferenceCreate;

   670 									  

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

   672 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallCapsChange(call1, 

   673 																	   notifyMobileCallCapsChangeStatus,

   674 																	   mobileCapsComp,

   675 																	   wantedStatus);

   676 												

   677 	// Check RMobileCall::GetMobileCallCaps includes iCallControlCaps in set of 

   678 	//			KCapsVoice |KCapsHold | KCapsHangUp | KCapsTransfer.

   679 	// Check RMobileCall::GetMobileCallCaps includes iCallEventCaps in set of 

   680 	//			KCapsLocalHold | KCapsLocalTransfer | KCapsRemoteHold | KCapsRemoteTerminate | 

   681 	//			KCapsRemoteConferenceCreate.

   682 	ASSERT_EQUALS(call1.GetMobileCallCaps(capsPckg), KErrNone, 

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

   684 	wantedMobileCaps.iCallControlCaps = RMobileCall::KCapsVoice | 

   685 											   RMobileCall::KCapsHold | 

   686 											   RMobileCall::KCapsHangUp;

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

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

   689 	

   690 	wantedMobileCaps.iCallEventCaps = RMobileCall::KCapsLocalHold | 

   691 											 RMobileCall::KCapsLocalTransfer |

   692 											 RMobileCall::KCapsRemoteHold | 

   693 											 RMobileCall::KCapsRemoteTerminate | 

   694 											 RMobileCall::KCapsRemoteConferenceCreate;

   695 	ASSERT_BITS_SET(mobileCallCaps.iCallEventCaps, wantedMobileCaps.iCallEventCaps,KNoUnwantedBits,

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

   697 

   698 

   699 	// ===  Check call status ===

   700 

   701 	// Check RCall::NotifyStatusChange completes with EStatusDialling -> 

   702 	RCall::TStatus expectedCallStatus = RCall::EStatusDialling;

   703 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   704 														 notifyStatusChangeStatus,

   705 														 callStatus,

   706 														 expectedCallStatus,

   707 														 wantedStatus);

   708 

   709 	// Check RCall::NotifyStatusChange completes with EStatusConnecting -> 	

   710 	expectedCallStatus = RCall::EStatusConnecting;

   711 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   712 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   713 													 notifyStatusChangeStatus,

   714 													 callStatus,

   715 													 expectedCallStatus,

   716 													 wantedStatus);

   717 

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

   719 	expectedCallStatus = RCall::EStatusConnected;

   720 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   721 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   722 													 notifyStatusChangeStatus,

   723 													 callStatus,

   724 													 expectedCallStatus,

   725 													 wantedStatus);	

   726 													 												 

   727 	// Check RCall::GetStatus returns EStatusConnected.

   728 	ASSERT_EQUALS(call1.GetStatus(callStatus),KErrNone,  

   729 			_L("RCall::GetStatus returned an error"));

   730 	ASSERT_EQUALS(callStatus, RCall::EStatusConnected, 

   731 			_L("RCall::GetStatus returned an unexpected call status"));

   732 	

   733 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling ->  

   734 	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDialling;

   735 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   736 															notifyMobileCallStatusChangeStatus,

   737 															mobileCallStatus,

   738 															expectedMobileCallStatus,

   739 															wantedStatus);

   740 

   741 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnecting ->															

   742 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   743 	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

   744 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   745 															notifyMobileCallStatusChangeStatus,

   746 															mobileCallStatus,

   747 															expectedMobileCallStatus,

   748 															wantedStatus);

   749 

   750 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.															

   751 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   752 	expectedMobileCallStatus = RMobileCall::EStatusConnected;															

   753 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   754 															notifyMobileCallStatusChangeStatus,

   755 															mobileCallStatus,

   756 															expectedMobileCallStatus,

   757 															wantedStatus);

   758 																														

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

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

   761 			_L("RMobileCall::GetMobileStatus returned an error"));

   762 	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusConnected, 

   763 			_L("RMobileCall::GetMobileStatus did not return a status EStatusConnected"));

   764 

   765 	

   766 	// ===  Check call info ===

   767 

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

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

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

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

   772 	User::After(KOneSecond*1);

   773 	ASSERT_EQUALS(call1.GetInfo(callInfo), KErrNone,  

   774 			_L("RCall::GetInfo returned an error"));

   775 	ASSERT_TRUE(callInfo.iCallName.Length() >0,  

   776 			_L("RCall::GetInfo returned an invalid  name"));

   777 	ASSERT_TRUE(callInfo.iLineName.Length() >0,  

   778 			_L("RCall::GetInfo returned an invalid  Line name"));

   779 	ASSERT_EQUALS(callInfo.iStatus, RCall::EStatusConnected, 

   780 			_L("RCall::GetInfo wrong iStatus, should be EStatusConnected"));

   781 	ASSERT_TRUE(callInfo.iDuration.Int() > 0,  

   782 			_L("RCall::GetInfo wrong iDuration, should be >0"));

   783 

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

   785 	// Check RMobileCall::GetMobileCallInfo returns data for attributes marked as valid in iValid.

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

   787 	ASSERT_EQUALS(call1.GetMobileCallInfo(callInfoPckg), KErrNone, 

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

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

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

   791 	ASSERT_TRUE(mobileCallInfo.iValid > 0, 

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

   793 

   794 	iCallControlTestHelper.CheckForValidCallInfo(mobileCallInfo, number);

   795 	

   796 	

   797 	////////////////////////////////////////////////////////////////

   798 	// TEST END

   799 	////////////////////////////////////////////////////////////////

   800 

   801     StartCleanup();

   802     

   803     // hang up the active call

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

   805 	CleanupStack::PushL(hangUpStatus);		

   806 	call1.HangUp(hangUpStatus);

   807 	WaitForRequestWithTimeOut(hangUpStatus, ETimeMedium);	

   808 	

   809 	// Pop

   810 	// notifyCapsChangeStatus

   811 	// notifyMobileCallCapsChangeStatus

   812 	// notifyStatusChangeStatus

   813 	// notifyMobileCallStatusChangeStatus

   814 	// dialStatus

   815 	// hangUpStatus

   816 	

   817 	CleanupStack::PopAndDestroy(6,&notifyCapsChangeStatus);

   818 	

   819 	return TestStepResult();

   820 	}

   821 

   822 TPtrC CCTSYIntegrationTestCallControl0003::GetTestStepName()

   823 /**

   824  * @return The test step name.

   825  */

   826 	{

   827 	return  _L("CCTSYIntegrationTestCallControl0003");

   828 	}

   829 

   830 

   831 

   832 CCTSYIntegrationTestCallControl0004::CCTSYIntegrationTestCallControl0004(CEtelSessionMgr& aEtelSessionMgr)

   833 	: CCTSYIntegrationTestCallControlBase(aEtelSessionMgr)

   834 /**

   835  * Constructor.

   836  */

   837 	{

   838 	SetTestStepName(CCTSYIntegrationTestCallControl0004::GetTestStepName());

   839 	}

   840 

   841 CCTSYIntegrationTestCallControl0004::~CCTSYIntegrationTestCallControl0004()

   842 /**

   843  * Destructor.

   844  */

   845 	{

   846 	}

   847 

   848 TVerdict CCTSYIntegrationTestCallControl0004::doTestStepL()

   849 /**

   850  * @SYMTestCaseID BA-CTSY-INT-CCON-0004

   851  * @SYMFssID BA/CTSY/CCON-0004

   852  * @SYMTestCaseDesc Dial a call which remote party rejects.

   853  * @SYMTestPriority High

   854  * @SYMTestActions RLine::NotifyStatusChange, RMobileLine::NotifyMobileLineStatusChange, RMobileCall::GetMobileCallStatus, RCall::NotifyStatusChange, RMobileCall::NotifyMobileCallStatusChange, RLine::GetStatus, RMobileLine::GetMobileLineStatus, RCall::GetStatus

   855  * @SYMTestExpectedResults Pass - Dial completes with an error.

   856  * @SYMTestType CIT

   857  * @SYMTestCaseDependencies live/rps

   858  *

   859  * Reason for test: Verify call and line status after call is rejected.

   860  *

   861  * @return - TVerdict code

   862  */

   863 	{

   864 

   865 	////////////////////////////////////////////////////////////////

   866 	// SET UP

   867 	////////////////////////////////////////////////////////////////

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

   869 	

   870 	// Check phone supports KCapsVoice

   871 	// Get Voice line 1 

   872 	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

   873 

   874 	// Get call 1 

   875 	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);

   876 

   877 	RLine::TCaps lineCaps; 

   878 	CHECK_EQUALS_L(voiceLine.GetCaps(lineCaps), KErrNone,  

   879 			_L("RMobileLine::GetCaps returned an error"));

   880 	CHECK_BITS_SET_L(lineCaps.iFlags, RLine::KCapsVoice, KNoUnwantedBits,  

   881 			_L("RLine::GetCaps returned wrong caps"));

   882 

   883 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

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

   885 

   886 	////////////////////////////////////////////////////////////////

   887 	// SET UP END

   888 	////////////////////////////////////////////////////////////////

   889 	

   890 	StartTest();

   891 	

   892 	////////////////////////////////////////////////////////////////

   893 	// TEST START

   894 	////////////////////////////////////////////////////////////////

   895 	

   896 	// post a notifier for RLine::NotifyStatusChange

   897 	RCall::TStatus lineStatus;

   898 	TCoreEtelRequestStatus<RLine> notifyStatusChangeStatus (voiceLine,&RLine::NotifyStatusChangeCancel);

   899 	CleanupStack::PushL(notifyStatusChangeStatus);

   900 	voiceLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   901 

   902 	// post a notifier for RMobileLine::NotifyMobileLineStatusChange

   903 	RMobileCall::TMobileCallStatus mobileLineStatus;

   904 	TExtEtelRequestStatus notifyMobileLineChangeStatus(voiceLine, EMobileLineNotifyMobileLineStatusChange);

   905 	CleanupStack::PushL(notifyMobileLineChangeStatus);

   906 	voiceLine.NotifyMobileLineStatusChange(notifyMobileLineChangeStatus, mobileLineStatus);

   907 

   908 	// post notifier for RCall::NotifyStatusChange

   909 	RCall::TStatus callStatus;

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

   911 	CleanupStack::PushL(notifyCallStatusChangeStatus);

   912 	call1.NotifyStatusChange(notifyCallStatusChangeStatus,callStatus);

   913 

   914 	// post a notifier for RMobileCall::NotifyMobileCallStatusChange

   915 	RMobileCall::TMobileCallStatus mobileCallStatus;

   916 	TExtEtelRequestStatus notifyMobileCallChangeStatus(call1, EMobileCallNotifyMobileCallStatusChange);

   917 	CleanupStack::PushL(notifyMobileCallChangeStatus);

   918 	call1.NotifyMobileCallStatusChange(notifyMobileCallChangeStatus, mobileCallStatus);

   919 

   920 	// Dial RPS which will reject the call. 

   921 	TPtrC number;

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

   923 	CleanupStack::PushL(dialStatus);		

   924 	RPSRejectNextCallL(EVoiceLine);

   925  	GetRPSNumber(EVoiceLine, number); // Voicemail should be deactivated for this number

   926 	call1.Dial(dialStatus, number);

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

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

   929 	ASSERT_TRUE(dialStatus.Int() != KErrNone,  

   930 			_L("RCall::Dial did not return an error"));

   931 

   932 	// ===  Check line status ===

   933 

   934 	// Check RLine::NotifyStatusChange completes with EStatusDialling -> EStatusHangingUp -> EStatusIdle

   935 	RCall::TStatus expectedLineStatus = RCall::EStatusDialling;

   936 	TInt expectedStatus = KErrNone;	

   937 	iCallControlTestHelper.WaitForLineNotifyStatusChange(voiceLine,

   938 														 notifyStatusChangeStatus,

   939 														 lineStatus,

   940 														 expectedLineStatus,

   941 														 expectedStatus);

   942 	

   943 

   944 	voiceLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   945 	expectedLineStatus = RCall::EStatusHangingUp;

   946 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10065);

   947 	iCallControlTestHelper.WaitForLineNotifyStatusChange(voiceLine,

   948 														 notifyStatusChangeStatus,

   949 														 lineStatus,

   950 														 expectedLineStatus,

   951 														 expectedStatus);	

   952 	 

   953 	voiceLine.NotifyStatusChange(notifyStatusChangeStatus,lineStatus);

   954 	expectedLineStatus = RCall::EStatusIdle;

   955 	iCallControlTestHelper.WaitForLineNotifyStatusChange(voiceLine,

   956 														 notifyStatusChangeStatus,

   957 														 lineStatus,

   958 														 expectedLineStatus,

   959 														 expectedStatus);	

   960 														 													 

   961 	// Check RLine::GetStatus returns EStatusIdle

   962 	ASSERT_EQUALS(voiceLine.GetStatus(lineStatus), KErrNone,  

   963 			_L("RLine::GetStatus returned an error"));

   964 	ASSERT_EQUALS(lineStatus, RCall::EStatusIdle,  

   965 			_L("RLine::GetStatus did not return EStatusIdle as expected"));

   966 	

   967 

   968 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDisconnecting -> EStatusIdle

   969 	RMobileCall::TMobileCallStatus expectedMobileLineStatus = RMobileCall::EStatusDisconnecting;

   970 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10065);

   971 	voiceLine.NotifyMobileLineStatusChange(notifyMobileLineChangeStatus, mobileLineStatus);

   972 	iCallControlTestHelper.WaitForMobileLineNotifyMobileLineStatusChange(voiceLine,

   973 																		notifyMobileLineChangeStatus,

   974 																		mobileLineStatus,

   975 																		expectedMobileLineStatus,

   976 																		expectedStatus);

   977 																		

   978 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusIdle 																		

   979 	expectedMobileLineStatus = RMobileCall::EStatusIdle;

   980 	voiceLine.NotifyMobileLineStatusChange(notifyMobileLineChangeStatus, mobileLineStatus);

   981 	iCallControlTestHelper.WaitForMobileLineNotifyMobileLineStatusChange(voiceLine,

   982 																		notifyMobileLineChangeStatus,

   983 																		mobileLineStatus,

   984 																		expectedMobileLineStatus,

   985 																		expectedStatus);																

   986 	// ===  Check call status ===

   987 

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

   989 	RCall::TStatus expectedCallStatus = RCall::EStatusHangingUp;

   990 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   991 														 notifyCallStatusChangeStatus,

   992 														 callStatus,

   993 														 expectedCallStatus,

   994 														 expectedStatus);

   995 														 

   996 	expectedCallStatus = RCall::EStatusIdle;

   997 	call1.NotifyStatusChange(notifyCallStatusChangeStatus,callStatus);

   998 	iCallControlTestHelper.WaitForCallNotifyStatusChange(call1,

   999 														 notifyCallStatusChangeStatus,

  1000 														 callStatus,

  1001 														 expectedCallStatus,

  1002 														 expectedStatus);

  1003 	// Check RCall::GetStatus returns EStatusIdle.

  1004 	ASSERT_EQUALS(call1.GetStatus(callStatus), KErrNone,  

  1005 			_L("RCall::GetStatus returned an Error"));

  1006 	ASSERT_EQUALS(callStatus, RCall::EStatusIdle,  

  1007 			_L("RCall::GetStatus did not return EStatusIdle"));

  1008 	

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

  1010 	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

  1011 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

  1012 																		notifyMobileCallChangeStatus,

  1013 																		mobileCallStatus,

  1014 																		expectedMobileCallStatus,

  1015 																		expectedStatus);

  1016 

  1017 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

  1018 	call1.NotifyMobileCallStatusChange(notifyMobileCallChangeStatus, mobileCallStatus);

  1019 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

  1020 																		notifyMobileCallChangeStatus,

  1021 																		mobileCallStatus,

  1022 																		expectedMobileCallStatus,

  1023 																		expectedStatus);	

  1024 

  1025 

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

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

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

  1029 	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusIdle,  

  1030 			_L("RMobileCall::GetMobileCallStatus did not return EStatusIdle"));

  1031 	

  1032 	////////////////////////////////////////////////////////////////

  1033 	// TEST END

  1034 	////////////////////////////////////////////////////////////////

  1035 

  1036     StartCleanup();

  1037     

  1038     // hang up the active call

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

  1040 	CleanupStack::PushL(hangUpStatus);

  1041 	call1.HangUp(hangUpStatus);

  1042 	WaitForRequestWithTimeOut(hangUpStatus, ETimeMedium);	

  1043     	

  1044 	// Pop

  1045 	// notifyStatusChangeStatus

  1046 	// notifyMobileLineChangeStatus

  1047 	// notifyCallStatusChangeStatus

  1048 	// notifyMobileCallChangeStatus

  1049 	// dialStatus

  1050 	// hangUpStatus

  1051 	CleanupStack::PopAndDestroy(6,&notifyStatusChangeStatus);

  1052 	

  1053 	return TestStepResult();

  1054 	}

  1055 

  1056 TPtrC CCTSYIntegrationTestCallControl0004::GetTestStepName()

  1057 /**

  1058  * @return The test step name.

  1059  */

  1060 	{

  1061 	return  _L("CCTSYIntegrationTestCallControl0004");

  1062 	}

  1063 

  1064 

  1065 

  1066 CCTSYIntegrationTestCallControl0005::CCTSYIntegrationTestCallControl0005(CEtelSessionMgr& aEtelSessionMgr)

  1067 	: CCTSYIntegrationTestCallControlBase(aEtelSessionMgr)

  1068 /**

  1069  * Constructor.

  1070  */

  1071 	{

  1072 	SetTestStepName(CCTSYIntegrationTestCallControl0005::GetTestStepName());

  1073 	}

  1074 

  1075 CCTSYIntegrationTestCallControl0005::~CCTSYIntegrationTestCallControl0005()

  1076 /**

  1077  * Destructor.

  1078  */

  1079 	{

  1080 	}

  1081 

  1082 TVerdict CCTSYIntegrationTestCallControl0005::doTestStepL()

  1083 /**

  1084  * @SYMTestCaseID BA-CTSY-INT-CCON-0005

  1085  * @SYMFssID BA/CTSY/CCON-0005

  1086  * @SYMTestCaseDesc Dial. Remote end doesn't pick up

  1087  * @SYMTestPriority High

  1088  * @SYMTestActions This requires a mobile SIM with voicemail deactivated. This test will only time out after 100seconds.

  1089  * @SYMTestExpectedResults Pass - Error returned.

  1090  * @SYMTestType CIT

  1091  * @SYMTestCaseDependencies live/manual

  1092  *

  1093  * Reason for test: Verify error is returned on attempt to dial.

  1094  *

  1095  * @return - TVerdict code

  1096  */

  1097 	{

  1098 

  1099 	////////////////////////////////////////////////////////////////

  1100 	// SET UP

  1101 	////////////////////////////////////////////////////////////////

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

  1103 	

  1104 	// Get Voice line 1 

  1105 	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

  1106 

  1107 	// Get call 1 

  1108 	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);

  1109 	

  1110 	// Check phone supports KCapsVoice.

  1111 	RLine::TCaps lineCaps; 

  1112 	CHECK_EQUALS_L(voiceLine.GetCaps(lineCaps), KErrNone,  

  1113 			_L("RMobileLine::GetCaps returned an error"));

  1114 	CHECK_BITS_SET_L(lineCaps.iFlags, RLine::KCapsVoice, KNoUnwantedBits,  

  1115 			_L("RLine::GetCaps returned wrong caps"));

  1116 

  1117 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

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

  1119 

  1120 	////////////////////////////////////////////////////////////////

  1121 	// SET UP END

  1122 	////////////////////////////////////////////////////////////////

  1123 	

  1124 	StartTest();

  1125 	

  1126 	////////////////////////////////////////////////////////////////

  1127 	// TEST START

  1128 	////////////////////////////////////////////////////////////////

  1129 	

  1130 	

  1131 	// Dial a number which will not answer. 	

  1132 	TPtrC number;

  1133 	GetStringFromConfig(KIniVoiceNumSection,KIniVoiceNumDoesNotConnect,number);

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