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

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include "cctsyintegrationtestprivacy.h"

    23 #include "cctsyinidata.h"

    24 

    25 

    26 	

    27 CCTSYIntegrationTestPrivacyBase::CCTSYIntegrationTestPrivacyBase(CEtelSessionMgr& aEtelSessionMgr)

    28 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iNetworkTestHelper(*this), iCallControlTestHelper(*this)

    29 /**

    30  * Constructor

    31  */

    32 	{

    33 	}

    34 

    35 CCTSYIntegrationTestPrivacyBase::~CCTSYIntegrationTestPrivacyBase()

    36 /*

    37  * Destructor

    38  */

    39 	{

    40 	}

    41 	

    42 

    43 CCTSYIntegrationTestPrivacy0001::CCTSYIntegrationTestPrivacy0001(CEtelSessionMgr& aEtelSessionMgr)

    44 	: CCTSYIntegrationTestPrivacyBase(aEtelSessionMgr)

    45 /**

    46  * Constructor.

    47  */

    48 	{

    49 	SetTestStepName(CCTSYIntegrationTestPrivacy0001::GetTestStepName());

    50 	}

    51 

    52 CCTSYIntegrationTestPrivacy0001::~CCTSYIntegrationTestPrivacy0001()

    53 /**

    54  * Destructor.

    55  */

    56 	{

    57 	}

    58 

    59 TVerdict CCTSYIntegrationTestPrivacy0001::doTestStepL()

    60 /**

    61  * @SYMTestCaseID BA-CTSY-INT-PRI-0001

    62  * @SYMFssID BA/CTSY/PRI-0001

    63  * @SYMTestCaseDesc Dial a voice call and get privacy confirmation.

    64  * @SYMTestPriority High

    65  * @SYMTestActions RMobileCall::NotifyMobileCallStatusChange, RMobileCall::NotifyPrivacyConfirmation, RCall::HangUp

    66  * @SYMTestExpectedResults Pass - Correct privacy notification received.

    67  * @SYMTestType CIT

    68  * @SYMTestCaseDependencies simulated/manual

    69  *

    70  * Reason for test: Verify privacy confirmation notification completes

    71  *

    72  * @return - TVerdict code

    73  */

    74 	{

    75 

    76 	//

    77 	// SET UP

    78 	//

    79 	

    80 	

    81 	ERR_PRINTF2(_L("<font color=Orange>$CTSYProblem: defect id = %d</font>"), 10090);

    82 	User::Leave(KErrNone);

    83 

    84 

    85 	// Check if we are on a simulated network.

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

    87  	iNetworkTestHelper.CheckPhoneConnectedToAniteL(phone);

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

    89 

    90 	// Get voice line 1. 

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

    92 	

    93 	// Get call 1. 

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

    95 

    96 

    97 	//

    98 	// SET UP END

    99 	//

   100 	

   101 	StartTest();

   102 	

   103 	//

   104 	// TEST START

   105 	//

   106 	

   107 	

   108 	// ===  Make a voice call where the network confirms that privacy is on. ===

   109 	

   110 	// Post notifier for RMobileCall::NotifyMobileCallStatusChange for call1

   111 	RMobileCall::TMobileCallStatus mobileCallStatus;

   112 	TExtEtelRequestStatus notifyCallStatusChange(call1, EMobileCallNotifyMobileCallStatusChange);

   113 	CleanupStack::PushL(notifyCallStatusChange);

   114 	call1.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

   115 	

   116 	// Dial a number that answers. 

   117 	TPtrC number;

   118 	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

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

   120 	CleanupStack::PushL(dialStatus);

   121 	call1.Dial(dialStatus, number);	

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

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

   124 	

   125 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected

   126 	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusConnected;

   127 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   128 																		notifyCallStatusChange,

   129 																		mobileCallStatus,

   130 																		expectedMobileCallStatus,

   131 																		KErrNone);

   132 

   133 	// Post notifier for RMobileCall::NotifyPrivacyConfirmation

   134 	RMobilePhone::TMobilePhonePrivacy phonePrivacy;

   135 	TExtEtelRequestStatus notifyPrivacy(call1, EMobileCallNotifyPrivacyConfirmation);

   136 	CleanupStack::PushL(notifyPrivacy);

   137 	call1.NotifyPrivacyConfirmation(notifyPrivacy, phonePrivacy);

   138 

   139 	// Simulated network should send confirmation that privacy is on.

   140 	DisplayUserInteractionPromptL(_L("Simulated network privacy should now be set to on"), ETimeMedium);

   141  

   142 	// Check RMobileCall::NotifyPrivacyConfirmation completes with EPrivacyOn

   143 	RMobilePhone::TMobilePhonePrivacy expectedphonePrivacy = RMobilePhone::EPrivacyOn;

   144 	iCallControlTestHelper.WaitForMobileCallNotifyPrivacyConfirmation(call1,

   145 																		notifyPrivacy,

   146 																		phonePrivacy,

   147 																		expectedphonePrivacy,

   148 																		KErrNone);

   149 	// Repost notifier

   150 	call1.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

   151 	

   152 	// Hang up call. 

   153 	TCoreEtelRequestStatus<RMobileCall> hangUpStatus (call1, &RMobileCall::HangUpCancel);	

   154 	CleanupStack::PushL(hangUpStatus);

   155 	call1.HangUp(hangUpStatus);

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

   157 	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RMobileCall::HangUp returned with error"));	

   158 	

   159 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle

   160 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   161 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   162 																		notifyCallStatusChange,

   163 																		mobileCallStatus,

   164 																		expectedMobileCallStatus,

   165 																		KErrNone);	

   166 																		

   167 	// ===  Make a voice call where the network confirms that privacy is off. ===

   168 

   169 	// Repost notifier

   170 	call1.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

   171 	

   172 	// Dial a number that answers. 

   173 	call1.Dial(dialStatus, number);	

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

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

   176 	

   177 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected

   178 	expectedMobileCallStatus = RMobileCall::EStatusConnected;

   179 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   180 																		notifyCallStatusChange,

   181 																		mobileCallStatus,

   182 																		expectedMobileCallStatus,

   183 																		KErrNone);

   184 	

   185 	// Repost notifier

   186 	call1.NotifyPrivacyConfirmation(notifyPrivacy, phonePrivacy);																	

   187 	

   188 	// Simulated network should send confirmation that privacy is off.

   189 	DisplayUserInteractionPromptL(_L("Simulated network privacy should now be set to off"), ETimeMedium);

   190  

   191 	// Check RMobileCall::NotifyPrivacyConfirmation completes with EPrivacyOff

   192 	expectedphonePrivacy = RMobilePhone::EPrivacyOff;

   193 	iCallControlTestHelper.WaitForMobileCallNotifyPrivacyConfirmation(call1,

   194 																		notifyPrivacy,

   195 																		phonePrivacy,

   196 																		expectedphonePrivacy,

   197 																		KErrNone);

   198 	

   199 	// Repost notifier

   200 	call1.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

   201 	

   202 	// Hang up call. 

   203 	call1.HangUp(hangUpStatus);

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

   205 	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RMobileCall::HangUp returned with error"));	

   206 	

   207 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle

   208 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   209 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   210 																		notifyCallStatusChange,

   211 																		mobileCallStatus,

   212 																		expectedMobileCallStatus,

   213 																		KErrNone);

   214 																		

   215 	

   216 	//

   217 	// TEST END

   218 	//

   219 

   220     StartCleanup();

   221 	

   222 	// Pop

   223 	// notifyCallStatusChange

   224 	// dialStatus

   225 	// notifyPrivacy

   226 	// hangUpStatus

   227 	CleanupStack::PopAndDestroy(4, &notifyCallStatusChange);

   228 	

   229 	return TestStepResult();

   230 	}

   231 

   232 TPtrC CCTSYIntegrationTestPrivacy0001::GetTestStepName()

   233 /**

   234  * @return The test step name.

   235  */

   236 	{

   237 	return _L("CCTSYIntegrationTestPrivacy0001");

   238 	}

   239 

   240 

   241 

   242 CCTSYIntegrationTestPrivacy0002::CCTSYIntegrationTestPrivacy0002(CEtelSessionMgr& aEtelSessionMgr)

   243 	: CCTSYIntegrationTestPrivacyBase(aEtelSessionMgr)

   244 /**

   245  * Constructor.

   246  */

   247 	{

   248 	SetTestStepName(CCTSYIntegrationTestPrivacy0002::GetTestStepName());

   249 	}

   250 

   251 CCTSYIntegrationTestPrivacy0002::~CCTSYIntegrationTestPrivacy0002()

   252 /**

   253  * Destructor.

   254  */

   255 	{

   256 	}

   257 

   258 TVerdict CCTSYIntegrationTestPrivacy0002::doTestStepL()

   259 /**

   260  * @SYMTestCaseID BA-CTSY-INT-PRI-0002

   261  * @SYMFssID BA/CTSY/PRI-0002

   262  * @SYMTestCaseDesc Dial a data call and get privacy confirmation.

   263  * @SYMTestPriority High

   264  * @SYMTestActions RMobileCall::NotifyMobileCallStatusChange, RMobileCall::NotifyPrivacyConfirmation, RCall::HangUp

   265  * @SYMTestExpectedResults Pass - Correct privacy notification received.

   266  * @SYMTestType CIT

   267  * @SYMTestCaseDependencies simulated/manual

   268  *

   269  * Reason for test: Verify privacy confirmation notification completes

   270  *

   271  * @return - TVerdict code

   272  */

   273 	{

   274 

   275 	//

   276 	// SET UP

   277 	//

   278 

   279 	ERR_PRINTF2(_L("<font color=Orange>$CTSYProblem: defect id = %d</font>"), 10091);

   280 	User::Leave(KErrNone);	

   281 

   282     // Check if we are on a simulated network.

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

   284  	iNetworkTestHelper.CheckPhoneConnectedToAniteL(phone);

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

   286 

   287 	// Get data line 1. 

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

   289 	

   290 	// Get call 1.

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

   292 

   293 

   294 	//

   295 	// SET UP END

   296 	//

   297 	

   298 	StartTest();

   299 	

   300 	//

   301 	// TEST START

   302 	//

   303 	

   304 	

   305 	// ===  Make a data call where the network confirms that privacy is on. ===

   306 	

   307 	// Set data call parameters

   308 	RMobileCall::TMobileDataCallParamsV1 mobileDataCallParams;

   309 	mobileDataCallParams.iService = RMobileCall::EServiceDataCircuitAsync;

   310 	mobileDataCallParams.iSpeed = RMobileCall::ESpeed9600;

   311 	mobileDataCallParams.iProtocol = RMobileCall::EProtocolV32;

   312 	mobileDataCallParams.iQoS = RMobileCall::EQoSNonTransparent;

   313 	RMobileCall::TMobileDataCallParamsV1Pckg mobileDataCallParamsPkg(mobileDataCallParams);

   314 

   315 	// Post notifier for RMobileCall::NotifyMobileCallStatusChange for call1

   316 	RMobileCall::TMobileCallStatus mobileCallStatusDataCall;

   317 	TExtEtelRequestStatus notifyDataCallStatusChange(call1, EMobileCallNotifyMobileCallStatusChange);

   318 	CleanupStack::PushL(notifyDataCallStatusChange);

   319 	call1.NotifyMobileCallStatusChange(notifyDataCallStatusChange, mobileCallStatusDataCall);

   320 	

   321 	// Dial a data call to a number that answers. 

   322 	TPtrC dataNumber;

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

   324 	TCoreEtelRequestStatus<RMobileCall> dialStatusDataCall(call1, &RMobileCall::DialCancel);

   325 	CleanupStack::PushL(dialStatusDataCall);

   326 	call1.Dial(dialStatusDataCall, mobileDataCallParamsPkg, dataNumber);

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

   328 	ASSERT_EQUALS(dialStatusDataCall.Int(), KErrNone,  _L("RMobileCall::Dial returned with an error"));

   329 

   330 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected

   331 	RMobileCall::TMobileCallStatus expectedDataCallStatus = RMobileCall::EStatusConnected;

   332 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   333 																		notifyDataCallStatusChange,

   334 																		mobileCallStatusDataCall,

   335 																		expectedDataCallStatus,

   336 																		KErrNone);

   337 	

   338 	// Post notifier for RMobileCall::NotifyPrivacyConfirmation

   339 	RMobilePhone::TMobilePhonePrivacy phonePrivacy;

   340 	TExtEtelRequestStatus notifyPrivacy(call1, EMobileCallNotifyPrivacyConfirmation);

   341 	CleanupStack::PushL(notifyPrivacy);

   342 	call1.NotifyPrivacyConfirmation(notifyPrivacy, phonePrivacy);

   343 

   344 	// Simulated network should send confirmation that privacy is on.

   345 	DisplayUserInteractionPromptL(_L("Simulated network privacy should now be set to on"), ETimeMedium);

   346  

   347 	// Check RMobileCall::NotifyPrivacyConfirmation completes with EPrivacyOn

   348 	RMobilePhone::TMobilePhonePrivacy expectedphonePrivacy = RMobilePhone::EPrivacyOn;

   349 	iCallControlTestHelper.WaitForMobileCallNotifyPrivacyConfirmation(call1,

   350 																		notifyPrivacy,

   351 																		phonePrivacy,

   352 																		expectedphonePrivacy,

   353 																		KErrNone);

   354 

   355 	// Repost notifier

   356 	call1.NotifyMobileCallStatusChange(notifyDataCallStatusChange, mobileCallStatusDataCall);

   357 	

   358 	// Hang up call. 

   359 	TCoreEtelRequestStatus<RMobileCall> hangUpStatus (call1, &RMobileCall::HangUpCancel);	

   360 	CleanupStack::PushL(hangUpStatus);

   361 	call1.HangUp(hangUpStatus);

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

   363 	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RMobileCall::HangUp returned with error"));	

   364 	

   365 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle

   366 	expectedDataCallStatus = RMobileCall::EStatusIdle;

   367 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   368 																		notifyDataCallStatusChange,

   369 																		mobileCallStatusDataCall,

   370 																		expectedDataCallStatus,

   371 																		KErrNone);

   372 

   373 	// ===  Make a data call where the network confirms that privacy is off. ===

   374 	

   375 	// Repost notifier

   376 	call1.NotifyMobileCallStatusChange(notifyDataCallStatusChange, mobileCallStatusDataCall);

   377 	

   378 	// Dial a data call to a number that answers. 

   379 	call1.Dial(dialStatusDataCall, mobileDataCallParamsPkg, dataNumber);

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

   381 	ASSERT_EQUALS(dialStatusDataCall.Int(), KErrNone,  _L("RMobileCall::Dial returned with an error"));

   382 

   383 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected

   384 	expectedDataCallStatus = RMobileCall::EStatusConnected;

   385 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   386 																		notifyDataCallStatusChange,

   387 																		mobileCallStatusDataCall,

   388 																		expectedDataCallStatus,

   389 																		KErrNone);

   390 	

   391 	// Repost notifier

   392 	call1.NotifyPrivacyConfirmation(notifyPrivacy, phonePrivacy);

   393 

   394 	// Simulated network should send confirmation that privacy is off.

   395 	DisplayUserInteractionPromptL(_L("Simulated network privacy should now be set to off"), ETimeMedium);

   396  

   397 	// Check RMobileCall::NotifyPrivacyConfirmation completes with EPrivacyOff

   398 	expectedphonePrivacy = RMobilePhone::EPrivacyOff;

   399 	iCallControlTestHelper.WaitForMobileCallNotifyPrivacyConfirmation(call1,

   400 																		notifyPrivacy,

   401 																		phonePrivacy,

   402 																		expectedphonePrivacy,

   403 																		KErrNone);

   404 

   405 	// Repost notifier

   406 	call1.NotifyMobileCallStatusChange(notifyDataCallStatusChange, mobileCallStatusDataCall);

   407 	

   408 	// Hang up call. 

   409 	call1.HangUp(hangUpStatus);

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

   411 	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RMobileCall::HangUp returned with error"));	

   412 	

   413 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle

   414 	expectedDataCallStatus = RMobileCall::EStatusIdle;

   415 	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   416 																		notifyDataCallStatusChange,

   417 																		mobileCallStatusDataCall,

   418 																		expectedDataCallStatus,

   419 																		KErrNone);

   420 

   421 	

   422 	//

   423 	// TEST END

   424 	//

   425 

   426     StartCleanup();

   427     

   428     // notifyDataCallStatusChange

   429     // dialStatusDataCall

   430     // notifyPrivacy

   431     // hangUpStatus

   432 	CleanupStack::PopAndDestroy(4, &notifyDataCallStatusChange);

   433 	

   434 	return TestStepResult();

   435 	}

   436 

   437 TPtrC CCTSYIntegrationTestPrivacy0002::GetTestStepName()

   438 /**

   439  * @return The test step name.

   440  */

   441 	{

   442 	return _L("CCTSYIntegrationTestPrivacy0002");

   443 	}

   444 

   445 

   446 

   447 CCTSYIntegrationTestPrivacy0003::CCTSYIntegrationTestPrivacy0003(CEtelSessionMgr& aEtelSessionMgr)

   448 	: CCTSYIntegrationTestPrivacyBase(aEtelSessionMgr)

   449 /**

   450  * Constructor.

   451  */

   452 	{

   453 	SetTestStepName(CCTSYIntegrationTestPrivacy0003::GetTestStepName());

   454 	}

   455 

   456 CCTSYIntegrationTestPrivacy0003::~CCTSYIntegrationTestPrivacy0003()

   457 /**

   458  * Destructor.

   459  */

   460 	{

   461 	}

   462 

   463 TVerdict CCTSYIntegrationTestPrivacy0003::doTestStepL()

   464 /**

   465  * @SYMTestCaseID BA-CTSY-INT-PRI-0003

   466  * @SYMFssID BA/CTSY/PRI-0003

   467  * @SYMTestCaseDesc Dial a fax call and get privacy confirmation.

   468  * @SYMTestPriority High

   469  * @SYMTestActions RMobileCall::NotifyMobileCallStatusChange, RMobileCall::NotifyPrivacyConfirmation, RCall::HangUp

   470  * @SYMTestExpectedResults Pass - Correct privacy notification received.

   471  * @SYMTestType CIT

   472  * @SYMTestCaseDependencies simulated/manual

   473  *

   474  * Reason for test: Verify privacy confirmation notification completes

   475  *

   476  * @return - TVerdict code

   477  */

   478 	{

   479 

   480 	//

   481 	// SET UP

   482 	//

   483 

   484 	

   485 	// Get fax line 1. 

   486 

   487 	// Get call 1. 

   488 

   489 

   490 	//

   491 	// SET UP END

   492 	//

   493 	

   494 	StartTest();

   495 	

   496 	//

   497 	// TEST START

   498 	//

   499 	

   500 	

   501 	// ===  Make a fax call where the network confirms that privacy is on. ===

   502 

   503 	// Dial a number that answers supplying any valid RMobileCall::TMobileCallParamsV1 as call params. 

   504 

   505 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected

   506 

   507 	// Simulated network should send confirmation that privacy is on. 

   508 

   509 	// Check RMobileCall::NotifyPrivacyConfirmation completes with EPrivacyOn

   510 

   511 	// Hang up call. 

   512 

   513 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle

   514 

   515 	// ===  Make a fax call where the network confirms that privacy is off. ===

   516 

   517 	// Dial a number that answers supplying any valid RMobileCall::TMobileCallParamsV1 as call params. 

   518 

   519 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected

   520 

   521 	// Simulated network should send confirmation that privacy is on. 

   522 

   523 	// Check RMobileCall::NotifyPrivacyConfirmation completes with EPrivacyOff

   524 

   525 	// Hang up call. 

   526 

   527 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle

   528 

   529 	

   530 	//

   531 	// TEST END

   532 	//

   533 

   534     StartCleanup();

   535 	

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

   537 	

   538 	return TestStepResult();

   539 	}

   540 

   541 TPtrC CCTSYIntegrationTestPrivacy0003::GetTestStepName()

   542 /**

   543  * @return The test step name.

   544  */

   545 	{

   546 	return _L("CCTSYIntegrationTestPrivacy0003");

   547 	}

   548 

   549 

   550