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

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include "cctsyintegrationtestconferencecallcontrol.h"

    23 #include "cctsyinidata.h"

    24 #include "etelmmerr.h"

    25 #include "cctsytestlogging.h"

    26 #include <stdlib.h>

    27 

    28 

    29 	

    30 CCTSYIntegrationTestConferenceCallControlBase::CCTSYIntegrationTestConferenceCallControlBase(CEtelSessionMgr& aEtelSessionMgr)

    31 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), 

    32 		iCallControlTsyTestHelper(*this),

    33 		iNetworkTsyTestHelper(*this)

    34 /**

    35  * Constructor

    36  */

    37 	{

    38 	}

    39 

    40 CCTSYIntegrationTestConferenceCallControlBase::~CCTSYIntegrationTestConferenceCallControlBase()

    41 /*

    42  * Destructor

    43  */

    44 	{

    45 	}

    46 	

    47 	

    48 /**

    49 * Make a call and verify the new status

    50 * @param aCall Call object

    51 * @param aNumber Number is be used

    52 * @return Status of conference call

    53 */

    54 RMobileCall::TMobileCallStatus CCTSYIntegrationTestConferenceCallControlBase::MakeCallL(RMobileCall& aCall, TPtrC& aNumber)

    55 	{

    56 	

    57 	// set up notification for call status changes

    58 	TExtEtelRequestStatus notifyCallStatus(aCall,EMobileCallNotifyMobileCallStatusChange);

    59 	CleanupStack::PushL(notifyCallStatus);

    60 	RMobileCall::TMobileCallStatus callStatus;	

    61 	aCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

    62 	

    63 	// Dial the number

    64 	TCoreEtelRequestStatus<RMobileCall> dialStatus(aCall, &RCall::DialCancel);

    65 	CleanupStack::PushL(dialStatus);

    66 	aCall.Dial(dialStatus, aNumber); 

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

    68 	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial returned an error") );

    69 

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

    71 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall, notifyCallStatus, callStatus, RMobileCall::EStatusDialling, KErrNone);

    72 	aCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

    73 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall, notifyCallStatus, callStatus, RMobileCall::EStatusConnecting, KErrNone);

    74 	aCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

    75 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall, notifyCallStatus, callStatus, RMobileCall::EStatusConnected, KErrNone);

    76 	

    77 	// Pop

    78 	// notifyCallStatus

    79 	// dialStatus

    80 	CleanupStack::PopAndDestroy(2, &notifyCallStatus);

    81 	

    82 	return callStatus;

    83 	}

    84 	

    85 

    86 /**

    87 * Place a call on hold and verify the new status

    88 * @param aCall Call object

    89 * @return Status of conference call

    90 */

    91 RMobileCall::TMobileCallStatus CCTSYIntegrationTestConferenceCallControlBase::HoldCallL( RMobileCall& aCall)

    92 	{

    93 

    94     // Post notification for call status change

    95 	TExtEtelRequestStatus notifyMobileCallStatusChangeStatus(aCall, EMobileCallNotifyMobileCallStatusChange);

    96 	CleanupStack::PushL(notifyMobileCallStatusChangeStatus);

    97 	RMobileCall::TMobileCallStatus mobileCallStatus;	

    98 	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

    99 

   100     // Hold call

   101 	TExtEtelRequestStatus reqHoldStatus(aCall, EMobileCallHold);

   102 	CleanupStack::PushL(reqHoldStatus);

   103 	aCall.Hold(reqHoldStatus);

   104 	ASSERT_EQUALS(WaitForRequestWithTimeOut(reqHoldStatus, ETimeMedium), KErrNone, _L("RMobileCall::Hold timed-out"));

   105 	ASSERT_EQUALS(reqHoldStatus.Int(), KErrNone, _L("RMobileCall::Hold returned an error"));

   106 

   107 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusHold.

   108 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

   109 															notifyMobileCallStatusChangeStatus,

   110 															mobileCallStatus,

   111 															RMobileCall::EStatusHold,

   112 															KErrNone);

   113     // Pop

   114 	// notifyMobileCallStatusChangeStatus

   115 	// reqHoldStatus

   116 	CleanupStack::PopAndDestroy(2, &notifyMobileCallStatusChangeStatus);

   117 	

   118 	return mobileCallStatus;

   119 	}

   120 

   121 

   122 /**

   123 * Add a call to a conference. Leaves on failure.

   124 * @param aConfCall Conference call object

   125 * @param aCall Call object to use

   126 * @param aNumber Number to dial

   127 *

   128 */

   129 void CCTSYIntegrationTestConferenceCallControlBase::AddCallToConferenceL( RMobileConferenceCall& aConfCall, 

   130 																				RMobileCall& aCall, TPtrC& aNumber,

   131 																				TInt aIndex )

   132 	{

   133 	

   134 	DEBUG_PRINTF3(_L("Adding call %d to conference : %S"), aIndex, &aNumber );

   135 	// Swap the conference call. 

   136 	TExtEtelRequestStatus reqSwapConfStatus(aConfCall,EMobileConferenceCallSwap);

   137 	CleanupStack::PushL(reqSwapConfStatus);

   138 	aConfCall.Swap(reqSwapConfStatus);

   139 	ASSERT_EQUALS( WaitForRequestWithTimeOut(reqSwapConfStatus,ETimeShort),KErrNone, _L("RMobileConferenceCall::Swap timed out"));

   140 	ASSERT_EQUALS( reqSwapConfStatus.Int(),KErrNone, _L("RMobileConferenceCall::Swap returned error"));

   141 	TEST_CHECK_POINT_L(_L("RMobileConferenceCall::Swap failed"));

   142 	

   143 	// Dial a number that answers 

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

   145 	RMobileCall::TMobileCallStatus callStatus = MakeCallL(aCall, aNumber);

   146 	ASSERT_EQUALS(callStatus,RMobileCall::EStatusConnected,_L("Failed to connect call"));

   147 	TEST_CHECK_POINT_L(_L("Failed to connect call"));

   148 			

   149 	// Set up notification

   150 	TExtEtelRequestStatus notifyConfEventStatus(aConfCall,EMobileConferenceCallNotifyConferenceEvent);

   151 	RMobileConferenceCall::TMobileConferenceEvent confEvent;

   152 	TName confEventCallName;

   153 	aConfCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, confEventCallName);

   154 

   155 	// Add call to the conference 

   156 	TExtEtelRequestStatus reqAddCallStatus(aConfCall,EMobileConferenceCallAddCall);

   157 	CleanupStack::PushL(reqAddCallStatus);

   158 

   159 	// Get the call info (need the name)

   160 	RCall::TCallInfo callInfo;

   161 	TInt err = aCall.GetInfo(callInfo);

   162 	ASSERT_EQUALS(err, KErrNone, _L("RCall::GetInfo returned error"));	

   163 	aConfCall.AddCall(reqAddCallStatus,callInfo.iCallName);

   164 	ASSERT_EQUALS(WaitForRequestWithTimeOut(reqAddCallStatus,ETimeShort),KErrNone, _L("RMobileConferenceCall::AddCall timed out"));

   165 	ASSERT_EQUALS(reqAddCallStatus.Int(),KErrNone, _L("RMobileConferenceCall::AddCall returned error"));

   166 	TEST_CHECK_POINT_L(_L("AddCallToConferenceL failed"));

   167 

   168 	// Check RMobileConferenceCall::NotifyConferenceEvent completes with EConferenceCallAdded

   169 	iCallControlTsyTestHelper.WaitForMobileConferenceCallNotifyConferenceEvent( aConfCall, 

   170 								notifyConfEventStatus,

   171 								confEvent,

   172 								RMobileConferenceCall::EConferenceCallAdded,

   173 								confEventCallName,

   174 								KErrNone);

   175 	

   176 	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceActive

   177 	RMobileConferenceCall::TMobileConferenceStatus confCallConfStatus;	

   178 	ASSERT_EQUALS(aConfCall.GetConferenceStatus(confCallConfStatus), KErrNone, _L("RMobileConferenceCall::GetConferenceStatus returned an error"));

   179 	ASSERT_EQUALS(confCallConfStatus, RMobileConferenceCall::EConferenceActive, _L("RMobileConferenceCall::GetConferenceStatus did not return EConferenceActive"));

   180 	TEST_CHECK_POINT_L(_L("AddCallToConferenceL failed"));

   181 	

   182 	// Pop								

   183 	// reqAddCallStatus

   184 	// reqSwapConfStatus

   185 	CleanupStack::PopAndDestroy(2,&reqSwapConfStatus);				

   186 	}

   187 

   188 /**

   189 * Check the conference call information returned 

   190 * @param aConfCall Conference call object

   191 * @param aNumber Dialled number for comparison

   192 * @param aCallCount 1-based call number 

   193 */

   194 void CCTSYIntegrationTestConferenceCallControlBase::CheckConfCallInfo(RMobileConferenceCall& aConfCall, 

   195 																	TPtrC& aNumber,

   196 																	TInt aCallCount)

   197 	{	

   198 	DEBUG_PRINTF2(_L("Checking call info from conf call for call %d"), aCallCount);

   199 

   200 	// Check RMobileConferenceCall::GetMobileCallInfo returns

   201 	RMobileCall::TMobileCallInfoV3 mobileCallInfo;

   202 	RMobileCall::TMobileCallInfoV3Pckg mobileCallInfoPkg(mobileCallInfo);

   203 	TInt err = aConfCall.GetMobileCallInfo(aCallCount-1, mobileCallInfoPkg);

   204 	ASSERT_EQUALS(err, KErrNone, _L("RMobileCall::GetMobileCallInfo returned an error"));

   205 

   206 	// Valid iCallName 

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

   208 						_L("RMobileConferenceCall::GetMobileCallInfo returned empty iCallName"));

   209 

   210 	// Correct number in iDialledParty 

   211 	TPtrC dialledPartyNumber(mobileCallInfo.iDialledParty.iTelNumber);

   212 	ASSERT_EQUALS_DES16( dialledPartyNumber, aNumber, 

   213 					_L("RMobileConferenceCall::GetMobileCallInfo iDialledParty number does not match called number"));

   214 

   215 	// Valid iLineName 

   216 	ASSERT_TRUE(mobileCallInfo.iLineName.Length() > 0, _L("RMobileConferenceCall::GetMobileCallInfo returned empty iLineName"));

   217 	

   218 	// iStatus of EStatusConnected 

   219 	ASSERT_EQUALS(mobileCallInfo.iStatus, RMobileCall::EStatusConnected, _L("RMobileConferenceCall::GetMobileCallInfo iDialledParty number does not match called number"));

   220 

   221 	//  Relevant bits set in iValid based on the above parameters 

   222 	// $CTSYProblem CTSY does not return the RMobileCall::KCallRemoteParty bit 

   223 	ASSERT_BITS_SET(mobileCallInfo.iValid, RMobileCall::KCallDialledParty, // | RMobileCall::KCallRemoteParty,

   224 						KNoUnwantedBits, _L("RMobileConferenceCall::GetMobileCallInfo returned invalid iValid"));

   225 

   226 	}

   227 

   228 

   229 

   230 CCTSYIntegrationTestConferenceCallControl0001::CCTSYIntegrationTestConferenceCallControl0001(CEtelSessionMgr& aEtelSessionMgr)

   231 	: CCTSYIntegrationTestConferenceCallControlBase(aEtelSessionMgr)

   232 /**

   233  * Constructor.

   234  */

   235 	{

   236 	SetTestStepName(CCTSYIntegrationTestConferenceCallControl0001::GetTestStepName());

   237 	}

   238 

   239 CCTSYIntegrationTestConferenceCallControl0001::~CCTSYIntegrationTestConferenceCallControl0001()

   240 /**

   241  * Destructor.

   242  */

   243 	{

   244 	}

   245 

   246 TVerdict CCTSYIntegrationTestConferenceCallControl0001::doTestStepL()

   247 /**

   248  * @SYMTestCaseID BA-CTSY-INT-CONC-0001

   249  * @SYMFssID BA/CTSY/CONC-0001

   250  * @SYMTestCaseDesc Create a conference call with no calls.

   251  * @SYMTestPriority High

   252  * @SYMTestActions RMobileConferenceCall::NotifyConferenceStatusChange, RMobileConferenceCall::EnumerateCalls, RMobileConferenceCall::GetCaps, RMobileConferenceCall::GetConferenceStatus, RMobileConferenceCall::CreateConference, RMobileConferenceCall::NotifyCapsChange

   253  * @SYMTestExpectedResults Pass - Conference creation fails with KErrNotReady.

   254  * @SYMTestType CIT

   255  * @SYMTestCaseDependencies live/automatic

   256  *

   257  * Reason for test: Verify creating a conference fails.

   258  * Verify conference call related notifications do not complete.

   259  *

   260  * @return - TVerdict code

   261  */

   262 	{

   263 

   264 	//

   265 	// SET UP

   266 	//

   267 

   268 	// Get conference call subsession. 

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

   270 	

   271 	// Make sure we are on the network

   272 	TInt err = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(phone);

   273 	CHECK_EQUALS_L( err, KErrNone, _L("Failed to register on home network"));

   274 

   275 	// Get conference call subsession.

   276 	RMobileConferenceCall& confCall = iEtelSessionMgr.GetConferenceCallL(KMainServer,KMainPhone,KMainConferenceCall);

   277 

   278 	//

   279 	// SET UP END

   280 	//

   281 	

   282 	StartTest();

   283 	

   284 	//

   285 	// TEST START

   286 	//

   287 	

   288 	// ===  Check conference status and information before creating a conference ===

   289 

   290 	// Check RMobileConferenceCall::GetCaps returns caps NOT in set of KCapsCreate | KCapsHangUp | KCapsSwap

   291 	TUint32 caps; 

   292 	TInt result = confCall.GetCaps(caps);

   293 	ASSERT_EQUALS(result, KErrNone, _L("RMobileConferenceCall::GetCaps failed."));

   294 	

   295 	TUint unwantedCaps = 	RMobileConferenceCall::KCapsCreate |

   296 						RMobileConferenceCall::KCapsHangUp |

   297 						RMobileConferenceCall::KCapsSwap;

   298 	

   299 	ASSERT_BITS_SET( caps,  KNoUnwantedBits, unwantedCaps, _L("RMobileConferenceCall::GetCaps returned wrong mask") );

   300 

   301 	// Check RMobileConferenceCall::EnumerateCalls returns aCount = 0

   302 	TInt callCount;

   303 	ASSERT_EQUALS( confCall.EnumerateCalls(callCount), KErrNone, 

   304 						_L("RMobileConferenceCall::EnumerateCalls failed."));

   305 	ASSERT_EQUALS(callCount,0, _L("RMobileConferenceCall::EnumerateCalls returned non-zero"));

   306 

   307 	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceIdle

   308 	RMobileConferenceCall::TMobileConferenceStatus confCallConfStatus;	

   309 	ASSERT_EQUALS(confCall.GetConferenceStatus(confCallConfStatus), KErrNone, 

   310 				_L("RMobileConferenceCall::GetConferenceStatus failed"));

   311 	ASSERT_EQUALS( RMobileConferenceCall::EConferenceIdle,confCallConfStatus,

   312 				_L("RMobileConferenceCall::GetConferenceStatus returned bad state"));

   313 	

   314 	// Request notification for RMobileConferenceCall::NotifyCapsChange 

   315 	TExtEtelRequestStatus notifyCapsChangeStatus(confCall, EMobileConferenceCallNotifyCapsChange);

   316 	CleanupStack::PushL(notifyCapsChangeStatus);

   317 	TUint32 confCallCaps;

   318 	confCall.NotifyCapsChange(notifyCapsChangeStatus, confCallCaps);	

   319 

   320 	// Request notification for RMobileConferenceCall::NotifyConferenceEvent 

   321 	TExtEtelRequestStatus notifyConfEventStatus(confCall, EMobileConferenceCallNotifyConferenceEvent);

   322 	CleanupStack::PushL(notifyConfEventStatus);

   323 	RMobileConferenceCall::TMobileConferenceEvent confEvent;

   324 	TName confEventName;

   325 	confCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, confEventName);

   326 

   327 	// Request notification for RMobileConferenceCall::NotifyConferenceStatusChange 

   328 	TExtEtelRequestStatus notifyConfStatusChange(confCall, EMobileConferenceCallNotifyConferenceStatusChange);

   329 	CleanupStack::PushL(notifyConfStatusChange);

   330 	RMobileConferenceCall::TMobileConferenceStatus confStatus;

   331 	confCall.NotifyConferenceStatusChange(notifyConfStatusChange, confStatus );

   332 

   333 	// Create a conference with RMobileConferenceCall::CreateConference 

   334 	TExtEtelRequestStatus createConfStatus(confCall, EMobileConferenceCallCreateConference);

   335 	CleanupStack::PushL(createConfStatus);

   336 	confCall.CreateConference(createConfStatus);

   337 		

   338 	ASSERT_EQUALS(WaitForRequestWithTimeOut(createConfStatus, ETimeMedium), KErrNone, 

   339 				_L("RMobileConferenceCall::CreateConference timed out."));

   340 	

   341 	// Check conference creation completes with KErrNotReady	

   342 	ASSERT_EQUALS( createConfStatus.Int(), KErrNotReady,

   343 				_L("RMobileConferenceCall::CreateConference did not return KErrNotReady") );

   344 

   345 

   346 	// ===  Check conference notifications did not complete ===

   347 

   348 	// Check RMobileConferenceCall::NotifyCapsChange is still KRequestPending

   349 	ASSERT_EQUALS( notifyCapsChangeStatus.Int(), KRequestPending, 

   350 					_L("NotifyCapsChange completed unexpectedly"));

   351 

   352 	// Check RMobileConferenceCall::NotifyConferenceEvent is still KRequestPending

   353 	ASSERT_EQUALS( notifyConfEventStatus.Int(), KRequestPending,

   354 					_L("NotifyConferenceEvent completed unexpectedly"));

   355 

   356 	// Check RMobileConferenceCall::NotifyConferenceStatusChange is still KRequestPending

   357 	ASSERT_EQUALS( notifyConfStatusChange.Int(), KRequestPending,

   358 					_L("NotifyConferenceStatusChange completed unexpectedly"));

   359 	

   360 	//

   361 	// TEST END

   362 	//

   363 

   364     StartCleanup();

   365 

   366 	CleanupStack::PopAndDestroy(4, &notifyCapsChangeStatus);

   367 	

   368 	return TestStepResult();

   369 	}

   370 

   371 TPtrC CCTSYIntegrationTestConferenceCallControl0001::GetTestStepName()

   372 /**

   373  * @return The test step name.

   374  */

   375 	{

   376 	return _L("CCTSYIntegrationTestConferenceCallControl0001");

   377 	}

   378 

   379 

   380 

   381 CCTSYIntegrationTestConferenceCallControl0002::CCTSYIntegrationTestConferenceCallControl0002(CEtelSessionMgr& aEtelSessionMgr)

   382 	: CCTSYIntegrationTestConferenceCallControlBase(aEtelSessionMgr)

   383 /**

   384  * Constructor.

   385  */

   386 	{

   387 	SetTestStepName(CCTSYIntegrationTestConferenceCallControl0002::GetTestStepName());

   388 	}

   389 

   390 CCTSYIntegrationTestConferenceCallControl0002::~CCTSYIntegrationTestConferenceCallControl0002()

   391 /**

   392  * Destructor.

   393  */

   394 	{

   395 	}

   396 

   397 TVerdict CCTSYIntegrationTestConferenceCallControl0002::doTestStepL()

   398 /**

   399  * @SYMTestCaseID BA-CTSY-INT-CONC-0002

   400  * @SYMFssID BA/CTSY/CONC-0002

   401  * @SYMTestCaseDesc Create a conference call with only one call.

   402  * @SYMTestPriority High

   403  * @SYMTestActions RMobileConferenceCall::NotifyConferenceStatusChange, RMobileConferenceCall::EnumerateCalls, RMobileConferenceCall::GetCaps, RMobileConferenceCall::GetConferenceStatus, RMobileConferenceCall::CreateConference, RMobileConferenceCall::NotifyCapsChange, RCall::GetStatus, RCall::HangUp, RCall::Dial, RCall::NotifyStatusChange

   404  * @SYMTestExpectedResults Pass - Conference creation fails with KErrMMEtelCallForbidden

   405  * @SYMTestType CIT

   406  * @SYMTestCaseDependencies live/automatic

   407  *

   408  * Reason for test: Verify creating a conference fails.

   409 Verify conference call related notifications can be cancelled.

   410  *

   411  * @return - TVerdict code

   412  */

   413 	{

   414 

   415 	//

   416 	// SET UP

   417 	//

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

   419 	iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(phone);

   420 

   421 	// Get conference call subsession. 

   422 	RMobileConferenceCall& confCall = iEtelSessionMgr.GetConferenceCallL(KMainServer,KMainPhone,KMainConferenceCall);

   423 																			   

   424 	// Get voice line 1. 

   425 	RMobileLine& voiceLine1 = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

   426 

   427 	// Get call 1. 

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

   429 

   430 

   431 	//

   432 	// SET UP END

   433 	//

   434 	

   435 	StartTest();

   436 	

   437 	//

   438 	// TEST START

   439 	//

   440 	

   441 	// post a notifier for RCall::NotifyStatusChange

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

   443 	CleanupStack::PushL(notifyStatusChangeStatus);

   444 	RCall::TStatus callStatus;

   445 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   446 	

   447 	// Dial a number that answers.

   448 	TPtrC number; 

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

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

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

   452 	CleanupStack::PushL(dialStatus);

   453 	call1.Dial(dialStatus, number);

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

   455 				_L("RCall::Dial timed-out"))

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

   457 	

   458 	// ===  Check call status ===

   459 

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

   461 	RCall::TStatus expectedCallStatus = RCall::EStatusDialling;

   462 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

   463 														 notifyStatusChangeStatus,

   464 														 callStatus,

   465 														 expectedCallStatus,

   466 														 KErrNone);	

   467 														 								 

   468 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   469 	expectedCallStatus = RCall::EStatusConnecting;

   470 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

   471 													 	notifyStatusChangeStatus,

   472 													 	callStatus,

   473 													 	expectedCallStatus,

   474 													 	KErrNone);

   475 													 

   476 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   477 	expectedCallStatus = RCall::EStatusConnected;

   478 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

   479 													 	notifyStatusChangeStatus,

   480 													 	callStatus,

   481 													 	expectedCallStatus,

   482 													 	KErrNone);														 

   483 													 

   484 	// Check RCall::GetStatus returns EStatusConnected.

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

   486 	ASSERT_EQUALS(callStatus, RCall::EStatusConnected, 

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

   488 

   489 	// ===  Check conference caps, status and info are correct. ===

   490 

   491 	// Check RMobileConferenceCall::GetCaps returns caps NOT in set of KCapsCreate | KCapsHangUp | KCapsSwap

   492 	TUint32 caps;

   493 	ASSERT_EQUALS(confCall.GetCaps(caps), KErrNone,

   494 				_L("RMobileConferenceCall::GetCaps returned an error"));

   495 	TUint32 wantedCaps = KNoWantedBits;

   496 	TUint32 unWantedCaps = RMobileConferenceCall::KCapsCreate | RMobileConferenceCall::KCapsHangUp | RMobileConferenceCall::KCapsSwap;

   497 	ASSERT_BITS_SET(caps, wantedCaps, unWantedCaps,

   498 				_L("RMobileConferenceCall::GetGaps returned unexpected caps"));

   499 

   500 	// Check RMobileConferenceCall::EnumerateCalls returns aCount = 0

   501 	TInt count;

   502 	ASSERT_EQUALS(confCall.EnumerateCalls(count), KErrNone, 

   503 				_L("RMobileConferenceCall::EnumerateCalls returned an error"));

   504 	ASSERT_EQUALS(count,0, _L("RMobileConferenceCall::EnumerateCalls did not return aCount = 0"));				

   505 

   506 	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceIdle

   507 	RMobileConferenceCall::TMobileConferenceStatus confStatus;

   508 	ASSERT_EQUALS(confCall.GetConferenceStatus(confStatus), KErrNone,

   509 				_L("RMobileConferenceCall::GetConferenceStatus returned an error"));

   510 	ASSERT_EQUALS(confStatus, RMobileConferenceCall::EConferenceIdle,

   511 				_L("RMobileConferenceCall::GetConferenceStatus did not return status of EConferenceIdle"));					

   512 

   513 	// Request notification for RMobileConferenceCall::NotifyCapsChange

   514 	TExtEtelRequestStatus notifyCapsChangeStatus (confCall, EMobileConferenceCallNotifyCapsChange);

   515 	CleanupStack::PushL(notifyCapsChangeStatus);	

   516 	confCall.NotifyCapsChange(notifyCapsChangeStatus, caps);

   517 	

   518 	// Request notification for RMobileConferenceCall::NotifyConferenceEvent 

   519 	TExtEtelRequestStatus notifyConfEventStatus(confCall, EMobileConferenceCallNotifyConferenceEvent);

   520 	CleanupStack::PushL(notifyConfEventStatus);

   521 	RMobileConferenceCall::TMobileConferenceEvent confEvent;

   522 	TName confName;

   523 	confCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, confName);	

   524 

   525 	// Request notification for RMobileConferenceCall::NotifyConferenceStatusChange 

   526 	TExtEtelRequestStatus notifyMobileConfStatusChangeStatus (confCall, EMobileConferenceCallNotifyConferenceStatusChange);

   527 	CleanupStack::PushL(notifyMobileConfStatusChangeStatus);

   528 	RMobileConferenceCall::TMobileConferenceStatus mobileConfStatus;

   529 	confCall.NotifyConferenceStatusChange(notifyMobileConfStatusChangeStatus,mobileConfStatus);							

   530 	

   531 	// Create a conference with RMobileConferenceCall::CreateConference 

   532 	TExtEtelRequestStatus createConfStatus (confCall, EMobileConferenceCallCreateConference);

   533 	CleanupStack::PushL(createConfStatus);

   534 	confCall.CreateConference(createConfStatus);

   535 	ASSERT_EQUALS(WaitForRequestWithTimeOut(createConfStatus, ETimeMedium), KErrNone, _L("RMobileConferenceCall::CreateConference timed-out"));

   536 	

   537 	// Check conference creation completes with KErrMMEtelCallForbidden

   538 	

   539 	ASSERT_EQUALS(createConfStatus.Int(), KErrMMEtelCallForbidden, _L("RMobileConferenceCall::CreateConference returned an error"));

   540 

   541 	// ===  Check conference notifications did not complete ===

   542 

   543 	// Check RMobileConferenceCall::NotifyCapsChange is still KRequestPending

   544 	ASSERT_EQUALS(notifyCapsChangeStatus.Int(), KRequestPending, _L("RMobileConferenceCall::NotifyCapsChange is not KRequestPending"));

   545 	

   546 	// Check RMobileConferenceCall::NotifyConferenceEvent is still KRequestPending

   547 	ASSERT_EQUALS(notifyConfEventStatus.Int(), KRequestPending, _L("RMobileConferenceCall::NotifyConferenceEvent is not KRequestPending"));

   548 

   549 	// Check RMobileConferenceCall::NotifyConferenceStatusChange is still KRequestPending

   550 	ASSERT_EQUALS(notifyMobileConfStatusChangeStatus.Int(), KRequestPending, _L("RMobileConferenceCall::NotifyConferenceStatusChange is not KRequestPending"));

   551 

   552 	// Hang up call.

   553 	ASSERT_EQUALS(call1.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));

   554 	

   555 	//

   556 	// TEST END

   557 	//

   558 

   559     StartCleanup();

   560     

   561     //createConfStatus

   562 	//notifyMobileConfStatusChangeStatus

   563 	//notifyConfEventStatus

   564 	//notifyCapsChangeStatus

   565 	//dialStatus

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

   567 	

   568 	return TestStepResult();

   569 	}

   570 

   571 TPtrC CCTSYIntegrationTestConferenceCallControl0002::GetTestStepName()

   572 /**

   573  * @return The test step name.

   574  */

   575 	{

   576 	return _L("CCTSYIntegrationTestConferenceCallControl0002");

   577 	}

   578 

   579 

   580 

   581 CCTSYIntegrationTestConferenceCallControl0003::CCTSYIntegrationTestConferenceCallControl0003(CEtelSessionMgr& aEtelSessionMgr)

   582 	: CCTSYIntegrationTestConferenceCallControlBase(aEtelSessionMgr)

   583 /**

   584  * Constructor.

   585  */

   586 	{

   587 	SetTestStepName(CCTSYIntegrationTestConferenceCallControl0003::GetTestStepName());

   588 	}

   589 

   590 CCTSYIntegrationTestConferenceCallControl0003::~CCTSYIntegrationTestConferenceCallControl0003()

   591 /**

   592  * Destructor.

   593  */

   594 	{

   595 	}

   596 

   597 TVerdict CCTSYIntegrationTestConferenceCallControl0003::doTestStepL()

   598 /**

   599  * @SYMTestCaseID BA-CTSY-INT-CONC-0003

   600  * @SYMFssID BA/CTSY/CONC-0003

   601  * @SYMTestCaseDesc Ensure that a data call cannot be part of a creation set

   602  * @SYMTestPriority High

   603  * @SYMTestActions RMobileConferenceCall::EnumerateCalls, RMobileConferenceCall::CreateConference, RMobileConferenceCall::GetConferenceStatus

   604  * @SYMTestExpectedResults Pass - Create conference fails.

   605  * @SYMTestType CIT

   606  * @SYMTestCaseDependencies live/automatic

   607  *

   608  * Reason for test: Verify creating a conference fails.

   609  *

   610  * @return - TVerdict code

   611  */

   612 	{

   613 

   614 	//

   615 	// SET UP

   616 	//

   617 

   618 	// Get the test numbers

   619 	TPtrC number; 

   620 	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("CTestStep::GetStringFromConfig did not complete as expected"));

   621 	TPtrC dataNumber; 

   622 	CHECK_TRUE_L(GetStringFromConfig(KIniDataNumSection, KIniDataNumber1, dataNumber) != EFalse, _L("CTestStep::GetStringFromConfig did not complete as expected"));

   623 	

   624 	// Get the phone session

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

   626 

   627 	// Make sure we are on the network

   628 	CHECK_EQUALS_L(iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("Failed to register on home network"));

   629 

   630 	// Get conference call

   631     RMobileConferenceCall& confCall = iEtelSessionMgr.GetConferenceCallL(KMainServer,KMainPhone,KMainConferenceCall);

   632 	

   633 	// Get voice line 1. 

   634 	RMobileLine& voiceLine1 = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

   635 

   636 	// Get call 1. 

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

   638 	

   639 	// Get data line 1. 

   640 	RMobileLine& dataLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KDataLine);

   641 

   642 	// Get call 2 with data line 1.

   643 	RMobileCall& dataCall = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KDataLine, KCall2);

   644 

   645 

   646 	//

   647 	// SET UP END

   648 	//

   649 	

   650 	StartTest();

   651 	

   652 	//

   653 	// TEST START

   654 	//

   655 

   656 

   657 	// Dial a number that answers on call 1.

   658 	RMobileCall::TMobileCallStatus call1Status = MakeCallL(call1, number);

   659 	ASSERT_EQUALS(call1Status, RMobileCall::EStatusConnected, _L("Failed to connect call"));

   660 

   661 	// Hold call 1.

   662 	call1Status = HoldCallL(call1);

   663 	ASSERT_EQUALS(call1Status, RMobileCall::EStatusHold, _L("Failed to hold the call"));

   664 

   665 	// Post notification for data call status changes

   666 	TExtEtelRequestStatus notifyDataCallStatus(dataCall, EMobileCallNotifyMobileCallStatusChange);

   667 	CleanupStack::PushL(notifyDataCallStatus);

   668 	RMobileCall::TMobileCallStatus dataCallStatus;	

   669 	dataCall.NotifyMobileCallStatusChange(notifyDataCallStatus, dataCallStatus);

   670 

   671 	// Dial a number that answers on call 2. 

   672 	TCoreEtelRequestStatus<RMobileCall> dataDialStatus(dataCall, &RCall::DialCancel);

   673 	CleanupStack::PushL(dataDialStatus);

   674 	RMobileCall::TMobileDataCallParamsV1 dataCallParams;

   675 	RMobileCall::TMobileDataCallParamsV1Pckg	dataCallParamsPkg(dataCallParams);

   676 	dataCallParams.iService = RMobileCall::EServiceDataCircuitAsyncRdi;

   677 	dataCallParams.iSpeed = RMobileCall::ESpeed9600;

   678 	dataCallParams.iProtocol = RMobileCall::EProtocolV32;

   679 	dataCallParams.iQoS = RMobileCall::EQoSNonTransparent;

   680 	dataCallParams.iRLPVersion = RMobileCall::ERLPSingleLinkVersion1;

   681 	dataCallParams.iV42bisReq = RMobileCall::EV42bisBothDirections;

   682 

   683 	// $CTSYKnownFailure defect id=50008. Data call cannot be made if an active or connecting call exists

   684 	// CMmDataCallTsy::Dial returns -2020 (KErrEtelCallAlreadyActive)

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

   686 	

   687 	dataCall.Dial(dataDialStatus, dataCallParamsPkg, dataNumber); 

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

   689 	ASSERT_EQUALS(dataDialStatus.Int(), KErrNone, _L("RCall::Dial returned an error"));

   690 	

   691 	// === Ensure both calls are connected for the test to start. ===

   692 

   693 	// Data call

   694 	RMobileCall::TMobileCallStatus expectedDataCallStatus = RMobileCall::EStatusConnected;

   695 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(dataCall,

   696                                                              notifyDataCallStatus,

   697                                                              dataCallStatus,

   698                                                              expectedDataCallStatus,

   699                                                              KErrNone);

   700 	

   701 	// Voice call

   702 	RCall::TStatus callStatus;

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

   704 	ASSERT_EQUALS(callStatus, RCall::EStatusConnected, _L("RCall::GetStatus did not return EStatusConnected as expected"));

   705 	

   706 	

   707 	// ===  Check conference caps, status and info are correct. ===

   708 

   709 	// Check RMobileConferenceCall::GetCaps returns caps NOT in set of KCapsCreate | KCapsHangUp | KCapsSwap

   710 	TUint32 caps;

   711 	TUint unwantedCaps = RMobileConferenceCall::KCapsCreate | RMobileConferenceCall::KCapsHangUp | RMobileConferenceCall::KCapsSwap;

   712 	ASSERT_EQUALS(confCall.GetCaps(caps), KErrNone, _L("RMobileConferenceCall::GetCaps failed."));

   713 	ASSERT_BITS_SET(caps, KNoWantedBits, unwantedCaps, _L("RMobileConferenceCall::GetCaps returned wrong mask"));

   714 

   715 	// Check RMobileConferenceCall::EnumerateCalls returns aCount = 0

   716 	TInt callCount;

   717 	ASSERT_EQUALS(confCall.EnumerateCalls(callCount), KErrNone, _L("RMobileConferenceCall::EnumerateCalls failed."));

   718 	ASSERT_EQUALS(callCount, 0, _L("RMobileConferenceCall::EnumerateCalls returned non-zero"));

   719 

   720 	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceIdle

   721 	RMobileConferenceCall::TMobileConferenceStatus confCallConfStatus;	

   722 	RMobileConferenceCall::TMobileConferenceStatus wantedConfCallConfStatus = RMobileConferenceCall::EConferenceIdle;	

   723 	ASSERT_EQUALS(confCall.GetConferenceStatus(confCallConfStatus), KErrNone, _L("RMobileConferenceCall::GetConferenceStatus failed"));

   724 	ASSERT_EQUALS(confCallConfStatus, wantedConfCallConfStatus, _L("RMobileConferenceCall::GetConferenceStatus returned wrong status"));

   725 

   726 	// Create the conference. 

   727 	TExtEtelRequestStatus createConfStatus(confCall, EMobileConferenceCallCreateConference);

   728 	CleanupStack::PushL(createConfStatus);

   729 	confCall.CreateConference(createConfStatus);

   730 	ASSERT_EQUALS(WaitForRequestWithTimeOut(createConfStatus, ETimeMedium), KErrNone, _L("RMobileConferenceCall::CreateConference timed out."));

   731 	

   732 	// Check this fails (error != KErrNone).

   733 	ASSERT_TRUE(createConfStatus.Int() != KErrNone, _L("RMobileConferenceCall::CreateConference did not return error as expected"));

   734 	

   735 	// Hangup calls

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

   737 	CleanupStack::PushL(hangUpStatus);

   738 	call1.HangUp(hangUpStatus);

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

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

   741 

   742 	dataCall.HangUp(hangUpStatus);

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

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

   745 

   746 	//

   747 	// TEST END

   748 	//

   749 

   750     StartCleanup();

   751     

   752     // Pop

   753     // notifyDataCallStatus

   754     // dataDialStatus

   755 	// createConfStatus

   756  	// hangUpStatus

   757     CleanupStack::PopAndDestroy(4, &notifyDataCallStatus);

   758     

   759 	return TestStepResult();

   760 	}

   761 

   762 TPtrC CCTSYIntegrationTestConferenceCallControl0003::GetTestStepName()

   763 /**

   764  * @return The test step name.

   765  */

   766 	{

   767 	return _L("CCTSYIntegrationTestConferenceCallControl0003");

   768 	}

   769 

   770 

   771 

   772 CCTSYIntegrationTestConferenceCallControl0004::CCTSYIntegrationTestConferenceCallControl0004(CEtelSessionMgr& aEtelSessionMgr)

   773 	: CCTSYIntegrationTestConferenceCallControlBase(aEtelSessionMgr)

   774 /**

   775  * Constructor.

   776  */

   777 	{

   778 	SetTestStepName(CCTSYIntegrationTestConferenceCallControl0004::GetTestStepName());

   779 	}

   780 

   781 CCTSYIntegrationTestConferenceCallControl0004::~CCTSYIntegrationTestConferenceCallControl0004()

   782 /**

   783  * Destructor.

   784  */

   785 	{

   786 	}

   787 

   788 TVerdict CCTSYIntegrationTestConferenceCallControl0004::doTestStepL()

   789 /**

   790  * @SYMTestCaseID BA-CTSY-INT-CONC-0004

   791  * @SYMFssID BA/CTSY/CONC-0004

   792  * @SYMTestCaseDesc Create a conference call with one active call and one held call then hang up conference call.

   793  * @SYMTestPriority High

   794  * @SYMTestActions RLine::NotifyStatusChange, RMobileConferenceCall::NotifyConferenceStatusChange, RMobileConferenceCall::GetMobileCallInfo, RMobileLine::NotifyMobileLineStatusChange, RMobileCall::GetMobileCallStatus, RMobileConferenceCall::NotifyCapsChange, RMobileCall::NotifyMobileCallStatusChange, RCall::NotifyStatusChange, RMobileLine::GetMobileLineStatus, RLine::GetStatus, RMobileConferenceCall::GetCaps, RMobileConferenceCall::EnumerateCalls, RMobileConferenceCall::GetConferenceStatus, RMobileConferenceCall::HangUp, RCall::GetStatus

   795  * @SYMTestExpectedResults Pass - Conference call created.

   796  * @SYMTestType CIT

   797  * @SYMTestCaseDependencies live/automatic

   798  * Reason for test: Verify conference creation successful.

   799 Verify conference call related notifications complete correctly and can be cancelled.

   800  *

   801  * @return - TVerdict code

   802  */

   803 	{

   804 

   805 	//

   806 	// SET UP

   807 	//

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

   809 	iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(phone);

   810 	

   811 	// Get conference call subsession. 

   812 	RMobileConferenceCall& confCall = iEtelSessionMgr.GetConferenceCallL(KMainServer,KMainPhone,KMainConferenceCall);

   813 		

   814 	// Get voice line 1.

   815 	RMobileLine& voiceLine1 = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

   816 

   817 	// Get call 1.

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

   819 

   820 	// Get call 2. 

   821 	RMobileCall& call2 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall2);

   822 

   823 	//

   824 	// SET UP END

   825 	//	

   826 	StartTest();

   827 

   828 

   829 	//

   830 	// TEST START

   831 	//

   832 	

   833 	// ===  Check conference caps, status and info are correct. ===

   834 

   835 	// Check RMobileConferenceCall::GetCaps returns caps NOT in set of KCapsCreate | KCapsHangUp | KCapsSwap

   836 

   837 	TUint32 caps;

   838 	TUint32 wantedCaps = KNoWantedBits;

   839 	TUint32 unWantedCaps = RMobileConferenceCall::KCapsCreate |

   840 					       RMobileConferenceCall::KCapsHangUp |

   841 						   RMobileConferenceCall::KCapsSwap;

   842 	ASSERT_EQUALS(confCall.GetCaps(caps), KErrNone, 

   843 				_L("RMobileConferenceCall::GetCaps returned an error"));

   844 	ASSERT_BITS_SET(caps, wantedCaps, unWantedCaps,

   845 				_L("RMobileConferenceCall::GetCaps  returned the wrong caps NOT set"));

   846 

   847 	// Check RMobileConferenceCall::EnumerateCalls returns aCount = 0

   848 	TInt count;

   849 	ASSERT_EQUALS(confCall.EnumerateCalls(count), KErrNone, 

   850 				_L("RMobileConferenceCall::EnumerateCalls returned an error"));

   851 	ASSERT_EQUALS(count,0, _L("RMobileConferenceCall::EnumerateCalls did not return aCount = 0"));				

   852 

   853 	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceIdle

   854 	RMobileConferenceCall::TMobileConferenceStatus confStatus;

   855 	ASSERT_EQUALS(confCall.GetConferenceStatus(confStatus), KErrNone,

   856 				_L("RMobileConferenceCall::GetConferenceStatus returned an error"));

   857 	ASSERT_EQUALS(confStatus, RMobileConferenceCall::EConferenceIdle,

   858 				_L("RMobileConferenceCall::GetConferenceStatus did not return status of EConferenceIdle"));					

   859 

   860 	// post a notifier for RCall::NotifyStatusChange

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

   862 	CleanupStack::PushL(notifyStatusChangeStatus);

   863 	RCall::TStatus callStatus;

   864 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   865 		

   866 	// Dial a number that answers using call 1. 

   867 	TPtrC number; 

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

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

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

   871 	CleanupStack::PushL(dialStatus);

   872 	call1.Dial(dialStatus, number); 

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

   874 				_L("RCall::Dial timed-out"))

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

   876 	TEST_CHECK_POINT_L(_L("Failed to dial call1"));

   877 	

   878 	// ===  Check call status for call 1 and 2 ===

   879 	// Check RCall::NotifyStatusChange for call 1 completes with EStatusDialling -> 

   880 	RCall::TStatus expectedCallStatus = RCall::EStatusDialling;

   881 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

   882 														 notifyStatusChangeStatus,

   883 														 callStatus,

   884 														 expectedCallStatus,

   885 														 KErrNone);	

   886 														 

   887 	// Check RCall::NotifyStatusChange for call 1 completes with EStatusConnecting -> 														 

   888 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   889 	expectedCallStatus = RCall::EStatusConnecting;

   890 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

   891 													 	notifyStatusChangeStatus,

   892 													 	callStatus,

   893 													 	expectedCallStatus,

   894 													 	KErrNone);

   895 													 

   896 	// Check RCall::NotifyStatusChange for call 1 completes with EStatusConnected.													 

   897 	call1.NotifyStatusChange(notifyStatusChangeStatus,callStatus);

   898 	expectedCallStatus = RCall::EStatusConnected;

   899 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call1,

   900 													 	notifyStatusChangeStatus,

   901 													 	callStatus,

   902 													 	expectedCallStatus,

   903 													 	KErrNone);														 

   904 													 

   905 	// Check RCall::GetStatus returns EStatusConnected.

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

   907 	ASSERT_EQUALS(callStatus, RCall::EStatusConnected, 

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

   909 

   910 	// Hold call 1. 

   911 	TExtEtelRequestStatus holdStatus (call1,EMobileCallHold);

   912 	CleanupStack::PushL(holdStatus);	

   913 	call1.Hold(holdStatus);

   914 	ASSERT_EQUALS(WaitForRequestWithTimeOut(holdStatus, ETimeMedium), KErrNone, 

   915 				_L("RMobileCall::Hold timed-out"));

   916 	ASSERT_EQUALS(dialStatus.Int(), KErrNone,

   917 				_L("RMobileCall::Hold returned an error"));

   918 

   919 	// post a notifier for RCall::NotifyStatusChange on call2

   920 	TCoreEtelRequestStatus<RCall> notifyStatusChangeStatus2 (call2,&RCall::NotifyStatusChangeCancel);

   921 	CleanupStack::PushL(notifyStatusChangeStatus2);

   922 	RCall::TStatus callStatus2;

   923 	call2.NotifyStatusChange(notifyStatusChangeStatus2,callStatus2);

   924 	

   925 	// post a notifier for RMobileConferenceCall::NotifyCapsChange

   926 	TExtEtelRequestStatus notifyCapsChangeStatus (call1,EMobileConferenceCallNotifyCapsChange);

   927 	CleanupStack::PushL(notifyCapsChangeStatus);	

   928 	confCall.NotifyCapsChange(notifyCapsChangeStatus, caps);

   929 	

   930 	// Dial a number that answers using call 2. 

   931 	TPtrC number2; 

   932 	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber2, number2) != EFalse, 

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

   934 	TCoreEtelRequestStatus<RMobileCall> dialStatus2(call2, &RCall::DialCancel);

   935 	CleanupStack::PushL(dialStatus2);

   936 	call2.Dial(dialStatus2, number2); 

   937 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus2, ETimeMedium), KErrNone, 

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

   939 	ASSERT_EQUALS(dialStatus2.Int(), KErrNone, _L("RCall::Dial returned an error"));

   940 	TEST_CHECK_POINT_L(_L("Failed to dial call 2"));

   941 	

   942 	// Check RCall::NotifyStatusChange for call 2 completes with EStatusDialling ->  

   943 	expectedCallStatus = RCall::EStatusDialling;

   944 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call2,

   945 														 notifyStatusChangeStatus2,

   946 														 callStatus2,

   947 														 expectedCallStatus,

   948 														 KErrNone);	

   949 														 

   950 	// Check RCall::NotifyStatusChange for call 2 completes with EStatusConnecting ->

   951 	call2.NotifyStatusChange(notifyStatusChangeStatus2,callStatus2);

   952 	expectedCallStatus = RCall::EStatusConnecting;

   953 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call2,

   954 													 notifyStatusChangeStatus2,

   955 													 callStatus2,

   956 													 expectedCallStatus,

   957 													 KErrNone);	

   958 													 

   959 	// Check RCall::NotifyStatusChange for call 2 completes with EStatusConnected.

   960 	call2.NotifyStatusChange(notifyStatusChangeStatus2,callStatus2);

   961 	expectedCallStatus = RCall::EStatusConnected;

   962 	iCallControlTsyTestHelper.WaitForCallNotifyStatusChange(call2,

   963 													 notifyStatusChangeStatus2,

   964 													 callStatus2,

   965 													 expectedCallStatus,

   966 													 KErrNone);	

   967 													 		

   968 	// Check RCall::GetStatus returns EStatusConnected.

   969 	ASSERT_EQUALS(call2.GetStatus(callStatus2),KErrNone, _L("RCall::GetStatus returned an error"));

   970 	ASSERT_EQUALS(callStatus2, RCall::EStatusConnected, 

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

   972 

   973 

   974 	// ===  Check conference caps indicate conference can now be created ===

   975 	// Check RMobileConferenceCall::NotifyCapsChange completes with caps in set of KCapsCreate

   976 	wantedCaps = RMobileConferenceCall::KCapsCreate;

   977 	unWantedCaps = KNoUnwantedBits;

   978 	iCallControlTsyTestHelper.WaitForMobileConferenceCallNotifyCapsChange(confCall,

   979 																	   notifyCapsChangeStatus,

   980 																	   caps,

   981 																	   wantedCaps,

   982 																	   unWantedCaps,

   983 																	   KErrNone);

   984 																		   

   985 	// Check RMobileConferenceCall::GetCaps returns caps in set of KCapsCreate

   986 	ASSERT_EQUALS(confCall.GetCaps(caps), KErrNone,

   987 				_L("RMobileConferenceCall::GetCaps returned an error"));

   988 	wantedCaps = RMobileConferenceCall::KCapsCreate;

   989 	unWantedCaps = KNoUnwantedBits;

   990 	ASSERT_BITS_SET(caps, wantedCaps, unWantedCaps,

   991 				_L("RMobileConferenceCall::GetGaps returned unexpected caps"));

   992 

   993 	// Post a notifier for RMobileConferenceCall::NotifyCapsChange

   994 	confCall.NotifyCapsChange(notifyCapsChangeStatus, caps);

   995 	

   996 	// Post a notifier for RMobileConferenceCall::NotifyConferenceEvent

   997 	TExtEtelRequestStatus notifyConfEventStatus(confCall,

   998 										EMobileConferenceCallNotifyConferenceEvent);

   999 	CleanupStack::PushL(notifyConfEventStatus);	

  1000 	RMobileConferenceCall::TMobileConferenceEvent confEvent;

  1001 	TName confName;

  1002 	confCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, confName);	

  1003 	

  1004 	// Post a notifier for RMobileConferenceCall::NotifyConferenceStatusChange

  1005 	TExtEtelRequestStatus notifyMobileConfStatusChangeStatus (confCall,

  1006 									EMobileConferenceCallNotifyConferenceStatusChange);

  1007 	CleanupStack::PushL(notifyMobileConfStatusChangeStatus);

  1008 	RMobileConferenceCall::TMobileConferenceStatus mobileConfStatus;

  1009 	confCall.NotifyConferenceStatusChange(notifyMobileConfStatusChangeStatus,mobileConfStatus);							

  1010 													   		

  1011 	// Create a conference. 

  1012 	TExtEtelRequestStatus createConfStatus (confCall,EMobileConferenceCallCreateConference);

  1013 	CleanupStack::PushL(createConfStatus);	

  1014 	confCall.CreateConference(createConfStatus);

  1015 	ASSERT_EQUALS(WaitForRequestWithTimeOut(createConfStatus, ETimeMedium), KErrNone, 

  1016 				_L("RMobileConferenceCall::CreateConference timed-out"));

  1017 	ASSERT_EQUALS(createConfStatus.Int(), KErrNone, 

  1018 				_L("RMobileConferenceCall::CreateConference returned an error"));	

  1019 	TEST_CHECK_POINT_L(_L("Failed to dial call"));

  1020 

  1021 				

  1022 	// ===  Check conference caps indicate conference can now be created ===

  1023 

  1024 	// Check RMobileConferenceCall::NotifyCapsChange completes with caps in set of KCapsHangUp | KCapsSwap

  1025 	// Check RMobileConferenceCall::NotifyCapsChange completes with caps NOT in set of KCapsCreate

  1026 	wantedCaps = RMobileConferenceCall::KCapsHangUp | RMobileConferenceCall::KCapsSwap;

  1027 	unWantedCaps = RMobileConferenceCall::KCapsCreate;

  1028 	iCallControlTsyTestHelper.WaitForMobileConferenceCallNotifyCapsChange(confCall,

  1029 																	   notifyCapsChangeStatus,

  1030 																	   caps,

  1031 																	   wantedCaps,

  1032 																	   unWantedCaps,

  1033 																	   KErrNone);

  1034 																	   	

  1035 	// Check RMobileConferenceCall::GetCaps returns caps in set of KCapsHangUp | KCapsSwap

  1036 	// Check RMobileConferenceCall::GetCaps returns caps NOT in set of KCapsCreate

  1037 	wantedCaps = RMobileConferenceCall::KCapsHangUp | RMobileConferenceCall::KCapsSwap;

  1038 	unWantedCaps = RMobileConferenceCall::KCapsCreate;	

  1039 	ASSERT_EQUALS(confCall.GetCaps(caps), KErrNone,

  1040 				_L("RMobileConferenceCall::GetCaps returned an error"));

  1041 	ASSERT_BITS_SET(caps, wantedCaps, unWantedCaps,

  1042 				_L("RMobileConferenceCall::GetGaps returned unexpected caps"));

  1043 

  1044 					

  1045 	// ===  Check conference event ===

  1046 

  1047 	// Check RMobileConferenceCall::NotifyConferenceEvent completes with EConferenceBuilt

  1048 	RMobileConferenceCall::TMobileConferenceEvent expectedEvent = RMobileConferenceCall::EConferenceBuilt;

  1049 	iCallControlTsyTestHelper.WaitForMobileConferenceCallNotifyConferenceEvent(confCall,

  1050 													 					notifyConfEventStatus,

  1051 													 					confEvent,

  1052 													 					expectedEvent,

  1053 													 					confName,

  1054 													 					KErrNone);

  1055 	

  1056 	ASSERT_EQUALS(confEvent, expectedEvent,	_L("RMobileConferenceCall::NotifyConferenceEvent returned unexpected event"));

  1057 													 						

  1058 	// ===  Check conference status ===

  1059 

  1060 	// Check RMobileConferenceCall::NotifyConferenceStatusChange completes with EConferenceActive

  1061 	RMobileConferenceCall::TMobileConferenceStatus expectedStatus = RMobileConferenceCall::EConferenceActive;

  1062 	iCallControlTsyTestHelper.WaitForMobileConferenceCallNotifyConferenceStatusChange(confCall,

  1063 													 					notifyMobileConfStatusChangeStatus,

  1064 													 					mobileConfStatus,

  1065 													 					expectedStatus,

  1066 													 					KErrNone);

  1067 

  1068 	// Check RMobileConferenceCall::GetConferenceStatus returns EConferenceActive

  1069 	ASSERT_EQUALS(confCall.GetConferenceStatus(confStatus), KErrNone,

  1070 					_L("RMobileConferenceCall::GetConferenceStatus returned an error"));

  1071 	ASSERT_EQUALS(confStatus, RMobileConferenceCall::EConferenceActive,

  1072 					_L("RMobileConferenceCall::GetConferenceStatus status was not EConferenceActive"));				

  1073 

  1074 

  1075 	// ===  Get call info belonging to individual call in the conference ===

  1076 	// Check RMobileConferenceCall::EnumerateCalls returns aCount = 2

  1077 	ASSERT_EQUALS(confCall.EnumerateCalls(count), KErrNone,

  1078 					_L("RMobileConferenceCall::EnumerateCalls returned an error"));

  1079 	ASSERT_EQUALS(count, 2, _L("RMobileConferenceCall::EnumerateCalls did not return aCount = 2"));						

  1080 	

  1081 	// Check RMobileConferenceCall::GetMobileCallInfo with aIndex = 0 returns KErrNone

  1082 	TInt index = 0;

  1083 	RMobileCall::TMobileCallInfoV1 callInfo;

  1084 	RMobileCall::TMobileCallInfoV1Pckg callInfoPckg(callInfo);

  1085 	ASSERT_EQUALS(confCall.GetMobileCallInfo(index,callInfoPckg), KErrNone,

  1086 					_L("RMobileConferenceCall::GetMobileCallInfo returned an error"));

  1087 					

  1088 	//   valid iCallName 

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

  1090 					_L("RMobileConferenceCall::GetMobileCallInfo did not return valid iCallName"));

  1091 					

  1092 	//   correct number in iDialledParty

  1093 	ASSERT_EQUALS_DES16(callInfo.iDialledParty.iTelNumber, number,

  1094 			_L("RMobileConferenceCall::GetMobileCallInfo did not return correct number in iDialledParty"));

  1095 					

  1096 	//   valid iLineName 

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

  1098 					_L("RMobileConferenceCall::GetMobileCallInfo did not return valid iLineName"));

  1099 

  1100 	//   iStatus of EStatusConnected 

  1101 	ASSERT_EQUALS(callInfo.iStatus, RMobileCall::EStatusConnected,

  1102 					_L("RMobileConferenceCall::GetMobileCallInfo did not return iStatus of EStatusConnected"));	

  1103 

  1104 	//   relevant bits set in iValid based on the above parameters 

  1105 	TUint32 wantedBits = RMobileCall::KCallDialledParty | RMobileCall::KCallId;

  1106 	TUint32 unWantedBits = KNoUnwantedBits;						

  1107 	ASSERT_BITS_SET(callInfo.iValid, wantedBits, unWantedBits,

  1108 					_L("RMobileConferenceCall::GetMobileCallInfo did not return relevant bits set in iValid"));	

  1109 

  1110 	// Check RMobileConferenceCall::GetMobileCallInfo with aIndex = 1 returns

  1111 	index = 1;

  1112 	ASSERT_EQUALS(confCall.GetMobileCallInfo(index,callInfoPckg), KErrNone,

  1113 					_L("RMobileConferenceCall::GetMobileCallInfo with aIndex = 1 returned an error"));

  1114 

  1115 	//   valid iCallName 

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

  1117 					_L("RMobileConferenceCall::GetMobileCallInfo did not return valid iCallName"));

  1118 

  1119 	//   correct number in iDialledParty 

  1120 	ASSERT_EQUALS_DES16(callInfo.iDialledParty.iTelNumber, number2,

  1121 					_L("RMobileConferenceCall::GetMobileCallInfo did not return correct number in iDialledParty"));

  1122 

  1123 	//   valid iLineName 

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

  1125 					_L("RMobileConferenceCall::GetMobileCallInfo did not return valid iLineName"));

  1126 

  1127 	//   iStatus of EStatusConnected 

  1128 	ASSERT_EQUALS(callInfo.iStatus, RMobileCall::EStatusConnected,

  1129 					_L("RMobileConferenceCall::GetMobileCallInfo did not return iStatus of EStatusConnected"));	

  1130 

  1131 	//   relevant bits set in iValid based on the above parameters 

  1132 	wantedBits = RMobileCall::KCallDialledParty | RMobileCall::KCallId;

  1133 	unWantedBits = KNoUnwantedBits;						

  1134 	ASSERT_BITS_SET(callInfo.iValid, wantedBits, unWantedBits,