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 // The TEFUnit test suite for CallEmergency in the Common TSY.

    15 // 

    16 //

    17 

    18 /**

    19  @file 

    20 */

    21 

    22 #include "cctsycallemergencyfu.h"

    23 #include <etel.h>

    24 #include <etelmm.h>

    25 #include <et_clsvr.h>

    26 #include <ctsy/mmtsy_names.h>

    27 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    28 #include "tmockltsydata.h"

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

    30 #include "e32property.h"

    31 

    32 #include <ssm/ssmadaptationcli.h>

    33 

    34 // for keys definition. These keys are  used to manage SSM_Stub behaviour

    35 #include "ssmstub_properties.h"

    36 

    37 #ifndef SYMBIAN_SYSTEM_STATE_MANAGEMENT

    38   const TUid KThisUID = {0x101F777C};

    39 #endif

    40 

    41 CTestSuite* CCTsyCallEmergencyFU::CreateSuiteL(const TDesC& aName)

    42 	{

    43 	SUB_SUITE;

    44 	

    45 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0001L);

    46 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0002L);

    47 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0003L);

    48 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0004L);

    49 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0005L);

    50 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0001bL);

    51 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0001cL);

    52 	

    53 	// tests for SSM plugin (System State Manager)

    54 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0001dL);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0001eL);

    56 

    57 	//test for dialling an emergency call when modem boot sequence has not run

    58 	ADD_TEST_STEP_ISO_CPP(CCTsyCallEmergencyFU, TestDialEmergencyCall0001fL);

    59 	END_SUITE;

    60 	}

    61 

    62 

    63 void CCTsyCallEmergencyFU::FillInEmergencyCallInfo(RMobileCall::TMobileCallInfoV1 &aInfo,

    64 		const TInt aCallId,

    65 		const TName& aCallName,

    66 		const RMobilePhone::TMobileService aService)

    67 	{

    68 	aInfo.iService = aService;

    69 	aInfo.iStatus = RMobileCall::EStatusIdle;

    70 	aInfo.iCallId = aCallId;

    71 	aInfo.iEmergency = ETrue;

    72 	aInfo.iCallName = aCallName;

    73 	switch ( aService )

    74 		{

    75 		case RMobilePhone::EAuxVoiceService:

    76 			aInfo.iLineName = KMmTsyVoice2LineName;

    77 			break;

    78 		case RMobilePhone::EVoiceService:

    79 		default:

    80 			aInfo.iLineName = KMmTsyVoice1LineName;

    81 			break;

    82 		}

    83 	aInfo.iValid = RMobileCall::KCallId | RMobileCall::KCallEmergency;

    84 	}

    85 

    86 

    87 //

    88 // Actual test cases

    89 //

    90 

    91 

    92 /**

    93 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0001

    94 @SYMComponent  telephony_ctsy

    95 @SYMTestCaseDesc Test support in CTSY for RMobileCall::DialEmergencyCall for voice calls

    96 @SYMTestPriority High

    97 @SYMTestActions Invokes RMobileCall::DialEmergencyCall for voice calls

    98 @SYMTestExpectedResults Pass

    99 @SYMTestType CT

   100 */

   101 void CCTsyCallEmergencyFU::TestDialEmergencyCall0001L()

   102 	{

   103 

   104 	OpenEtelServerL(EUseExtendedError);

   105 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   106 	OpenPhoneL();

   107 

   108 	RBuf8 data;

   109 	CleanupClosePushL(data);

   110 

   111 	RLine line;

   112 	TInt err = line.Open(iPhone, KMmTsyVoice1LineName);

   113 	ASSERT_EQUALS(KErrNone, err)

   114     CleanupClosePushL(line);

   115 	

   116 	TRequestStatus reqStatus;

   117 

   118 	RMobileCall mobileCall;

   119 	TName callName;

   120 	err = mobileCall.OpenNewCall(line, callName);

   121 	ASSERT_EQUALS(KErrNone, err);

   122 	CleanupClosePushL(mobileCall);

   123 

   124 	RMobileENStore::TEmergencyNumber number(_L("911"));

   125 	TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData(number);

   126 

   127 	const TInt KCallId = 1;

   128 	RMobilePhone::TMobileService KMobileService = RMobilePhone::EVoiceService;

   129 	RMobileCall::TMobileCallInfoV1 callInfo;

   130 	FillInEmergencyCallInfo(callInfo, KCallId, callName, KMobileService);

   131 	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData(KCallId, KMobileService, callInfo);

   132 	

   133 	RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle;

   134 	TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData(KCallId, KMobileService, mobileCallStatus);

   135 

   136  	//-------------------------------------------------------------------------

   137 	// TEST A: failure to dispatch request to LTSY

   138  	//-------------------------------------------------------------------------

   139  	

   140 	numberLtsyData.SerialiseL(data);

   141 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNotSupported);

   142 

   143 	mobileCall.DialEmergencyCall(reqStatus, number);

   144 	User::WaitForRequest(reqStatus);

   145 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

   146 	AssertMockLtsyStatusL();

   147 	

   148 	//-------------------------------------------------------------------------

   149 	// TEST B1: failure on completion of pending request from LTSY->CTSY

   150  	//-------------------------------------------------------------------------

   151 

   152 	data.Close();

   153 	numberLtsyData.SerialiseL(data);

   154 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   155 

   156     data.Close();

   157     completeCallInfoData.SerialiseL(data);

   158     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   159 

   160     data.Close();

   161     completeCallStatusData.SerialiseL(data);

   162     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGeneral, data);

   163 

   164 	mobileCall.DialEmergencyCall(reqStatus, number);

   165 	User::WaitForRequest(reqStatus);

   166 	ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   167 	AssertMockLtsyStatusL();

   168 

   169 	//-------------------------------------------------------------------------

   170 	// TEST B2: failure on completion of pending request from LTSY->CTSY

   171 	// when LTSY returns EStatusIdle call status

   172  	//-------------------------------------------------------------------------

   173 

   174 	data.Close();

   175 	numberLtsyData.SerialiseL(data);

   176 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   177 

   178     data.Close();

   179     completeCallInfoData.SerialiseL(data);

   180     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   181 

   182     data.Close();

   183     completeCallStatusData.SerialiseL(data);

   184     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   185 

   186 	mobileCall.DialEmergencyCall(reqStatus, number);

   187 	User::WaitForRequest(reqStatus);

   188 	ASSERT_EQUALS(KErrNotReady, reqStatus.Int());

   189 	AssertMockLtsyStatusL();

   190 

   191  	//-------------------------------------------------------------------------

   192 	// TEST C1: Successful completion request of

   193 	// RMobileCall::DialEmergencyCall.

   194  	//-------------------------------------------------------------------------

   195 	

   196 	data.Close();

   197 	numberLtsyData.SerialiseL(data);

   198 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   199 

   200     data.Close();

   201     completeCallInfoData.SerialiseL(data);

   202     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   203 

   204     data.Close();

   205     mobileCallStatus = RMobileCall::EStatusDialling;

   206     completeCallStatusData.SerialiseL(data);

   207     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   208 

   209     data.Close();

   210     mobileCallStatus = RMobileCall::EStatusConnecting;

   211     completeCallStatusData.SerialiseL(data);

   212     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   213 

   214     data.Close();

   215     mobileCallStatus = RMobileCall::EStatusConnected;

   216     completeCallStatusData.SerialiseL(data);

   217     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   218 

   219 	mobileCall.DialEmergencyCall(reqStatus, number);

   220 	User::WaitForRequest(reqStatus);

   221 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   222 	AssertMockLtsyStatusL();

   223 

   224  	//-------------------------------------------------------------------------

   225 	// TEST: failure to dispatch request to CTSY 

   226 	// when emergency call is allready dialed

   227  	//-------------------------------------------------------------------------

   228 

   229 	mobileCall.DialEmergencyCall(reqStatus, number);

   230 	User::WaitForRequest(reqStatus);

   231 	ASSERT_EQUALS(KErrNotReady, reqStatus.Int());

   232 	AssertMockLtsyStatusL();

   233 

   234 	PrepareCallCloseL(KCallId, KMobileService);

   235 	CleanupStack::PopAndDestroy(&mobileCall);

   236 	AssertMockLtsyStatusL();

   237 

   238 	//-------------------------------------------------------------------------

   239 	// TEST C2: Successful completion request of

   240 	// RMobileCall::DialEmergencyCall in OOM condition.

   241  	//-------------------------------------------------------------------------

   242 	

   243 	data.Close();

   244 	numberLtsyData.SerialiseL(data);

   245 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   246 

   247     data.Close();

   248     completeCallInfoData.SerialiseL(data);

   249     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   250 

   251     data.Close();

   252     mobileCallStatus = RMobileCall::EStatusDialling;

   253     completeCallStatusData.SerialiseL(data);

   254     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   255 

   256     data.Close();

   257     mobileCallStatus = RMobileCall::EStatusConnecting;

   258     completeCallStatusData.SerialiseL(data);

   259     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   260 

   261     data.Close();

   262     mobileCallStatus = RMobileCall::EStatusConnected;

   263     completeCallStatusData.SerialiseL(data);

   264     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   265 

   266 	err = iTelServer.SetPriorityClientV2();

   267 	ASSERT_EQUALS(KErrNone, err);

   268 

   269 	err = mobileCall.OpenNewCall(line);

   270 	ASSERT_EQUALS(KErrNone, err);

   271 	CleanupClosePushL(mobileCall);

   272 	

   273 	// simulate a heap allocation failure

   274 	User::__DbgSetAllocFail(EFalse, RAllocator::EDeterministic, 1);

   275 	User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1);

   276 

   277 	// test RMobileCall::DialEmergencyCall in out-of-memory condition

   278 	mobileCall.DialEmergencyCall(reqStatus, number);

   279 	User::WaitForRequest(reqStatus);

   280 

   281 	// turn back a heap allocation possibility

   282 	User::__DbgSetAllocFail(EFalse, RAllocator::ENone, 1);

   283 	User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);

   284 

   285 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: Dependent on Symbian System State Manager.  DEF141353 </font>"), 210106);

   286 	    // Symbian SSM allocates memory in call to Connect() in ActivateRfForEmergencyCall

   287 	   

   288 	// check results

   289 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   290 	AssertMockLtsyStatusL();

   291 

   292 	//-------------------------------------------------------------------------

   293 	// TEST E: Unsolicited completion of RMobileCall::DialEmergencyCall

   294 	// from LTSY.

   295  	//-------------------------------------------------------------------------

   296 

   297 	TRequestStatus mockLtsyStatus;

   298 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   299 	//send completion

   300 	TMockLtsyCallData0 completeEmptyLtsyData(KCallId, KMobileService);

   301 	data.Close();

   302 	completeEmptyLtsyData.SerialiseL(data);

   303 	iMockLTSY.CompleteL(EMobileCallDialEmergencyCall, KErrNone, data);

   304 	// wait for completion

   305 	User::WaitForRequest(mockLtsyStatus);

   306 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   307 	

   308 	// increase coverage

   309 

   310 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   311     data.Close();

   312     mobileCallStatus = RMobileCall::EStatusIdle;

   313     completeCallStatusData.SerialiseL(data);

   314     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   315 	User::WaitForRequest(mockLtsyStatus);

   316 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   317 

   318 	AssertMockLtsyStatusL();

   319 	CleanupStack::PopAndDestroy(2); // mobileCall, line

   320 	CleanupStack::PopAndDestroy(2, this); // data, this

   321 	

   322 	}

   323 

   324 

   325 /**

   326 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0002

   327 @SYMComponent  telephony_ctsy

   328 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::DialEmergencyCall for voice calls

   329 @SYMTestPriority High

   330 @SYMTestActions Invokes cancelling of RMobileCall::DialEmergencyCall for voice calls

   331 @SYMTestExpectedResults Pass

   332 @SYMTestType CT

   333 */

   334 void CCTsyCallEmergencyFU::TestDialEmergencyCall0002L()

   335 	{

   336 

   337 	OpenEtelServerL(EUseExtendedError);

   338 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   339 	OpenPhoneL();

   340 

   341 	RBuf8 data;

   342 	CleanupClosePushL(data);

   343 

   344 	RLine line;

   345 	TInt err = line.Open(iPhone, KMmTsyVoice1LineName);

   346 	ASSERT_EQUALS(KErrNone, err)

   347     CleanupClosePushL(line);

   348 	

   349 	TRequestStatus reqStatus;

   350 	TRequestStatus mockLtsyStatus;

   351 

   352 	TName callName;

   353 	RMobileENStore::TEmergencyNumber number(_L("911"));

   354 	TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData(number);

   355 

   356 	const RMobilePhone::TMobileService KMobileService = RMobilePhone::EVoiceService;

   357 	const TInt KCallId1 = 1;

   358 	RMobileCall::TMobileCallInfoV1 callInfo;

   359 	FillInEmergencyCallInfo(callInfo, KCallId1, callName, KMobileService);

   360 	callInfo.iValid = RMobileCall::KCallId | RMobileCall::KCallEmergency;

   361 	

   362 	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData(KCallId1, KMobileService, callInfo);

   363 	

   364 	TInt hangUpCause = KErrGsmReleaseByUser;

   365 	TBool autoStChangeDisable = ETrue;

   366     TMockLtsyCallData2<TInt, TBool> expHangUpData(KCallId1, KMobileService, 

   367                                               hangUpCause, 

   368                                               autoStChangeDisable);

   369 

   370 	TMockLtsyCallData0 completeEmptyLtsyData(KCallId1, KMobileService);

   371 

   372 	RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle;

   373 	TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData(KCallId1, KMobileService, mobileCallStatus);

   374 

   375 	//-------------------------------------------------------------------------

   376     // Test cancelling of RMobileCall::DialEmergencyCall

   377     // before than LTSY sends any completions

   378     //-------------------------------------------------------------------------

   379 

   380     RMobileCall mobileCall1;

   381     err = mobileCall1.OpenNewCall(line, callName);

   382     ASSERT_EQUALS(KErrNone, err);

   383     CleanupClosePushL(mobileCall1);

   384 

   385     numberLtsyData.SerialiseL(data);

   386     iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   387     

   388     mobileCall1.DialEmergencyCall(reqStatus, number);

   389     User::After(1000); // Delay needed to reach DialEmergencyCall request to LTSY

   390     mobileCall1.CancelAsyncRequest(EMobileCallDialEmergencyCall);

   391     

   392     data.Close();

   393     iMockLTSY.NotifyTerminated(mockLtsyStatus);

   394     completeCallInfoData.SerialiseL(data);

   395     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   396     User::WaitForRequest(mockLtsyStatus);      

   397     

   398     data.Close();

   399     mobileCallStatus = RMobileCall::EStatusDialling; 

   400     completeCallStatusData.SerialiseL(data);

   401     iMockLTSY.NotifyTerminated(mockLtsyStatus);

   402         

   403     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, hangUpCause, data);

   404       

   405     data.Close();

   406     expHangUpData.SerialiseL(data);

   407     iMockLTSY.ExpectL(EEtelCallHangUp, data, KErrNone);

   408        

   409     User::WaitForRequest(mockLtsyStatus);

   410    

   411     data.Close();

   412     mobileCallStatus = RMobileCall::EStatusIdle;

   413     completeCallStatusData.SerialiseL(data);

   414     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, hangUpCause, data);

   415     User::WaitForRequest(reqStatus);

   416     

   417     ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   418 

   419     CleanupStack::PopAndDestroy(&mobileCall1);

   420     AssertMockLtsyStatusL();

   421 	//-------------------------------------------------------------------------

   422 	// Test cancelling of RMobileCall::DialEmergencyCall

   423 	// after callId is changed

   424  	//-------------------------------------------------------------------------

   425 

   426 	RMobileCall mobileCall2;

   427 	err = mobileCall2.OpenNewCall(line, callName);

   428 	ASSERT_EQUALS(KErrNone, err);

   429 	CleanupClosePushL(mobileCall2);

   430 

   431     data.Close();

   432 	numberLtsyData.SerialiseL(data);

   433 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   434 

   435     data.Close();

   436     mobileCallStatus = RMobileCall::EStatusDialling;

   437     completeCallStatusData.SerialiseL(data);

   438     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10);

   439 

   440     mobileCall2.DialEmergencyCall(reqStatus, number);

   441 

   442 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   443     data.Close();

   444 	callInfo.iCallName = callName;

   445     completeCallInfoData.SerialiseL(data);

   446     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   447 	User::WaitForRequest(mockLtsyStatus);

   448 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   449 	

   450 	data.Close();

   451 	expHangUpData.SerialiseL(data);

   452     iMockLTSY.ExpectL(EEtelCallHangUp, data, KErrNone);

   453 

   454     data.Close();

   455     mobileCallStatus = RMobileCall::EStatusIdle;

   456     completeCallStatusData.SerialiseL(data);

   457     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, hangUpCause, data, 10);

   458 

   459 	mobileCall2.CancelAsyncRequest(EMobileCallDialEmergencyCall);

   460 	

   461 	User::WaitForRequest(reqStatus);

   462 	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   463 

   464 	CleanupStack::PopAndDestroy(&mobileCall2);

   465 	AssertMockLtsyStatusL();

   466 

   467 	//-------------------------------------------------------------------------

   468 	// Test cancelling of RMobileCall::DialEmergencyCall

   469 	// after call status is changed to dialling

   470  	//-------------------------------------------------------------------------

   471 

   472 	RMobileCall mobileCall3;

   473 	err = mobileCall3.OpenNewCall(line, callName);

   474 	ASSERT_EQUALS(KErrNone, err);

   475 	CleanupClosePushL(mobileCall3);

   476 

   477     data.Close();

   478 	numberLtsyData.SerialiseL(data);

   479 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   480 

   481 	mobileCall3.DialEmergencyCall(reqStatus, number);

   482 

   483 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   484     data.Close();

   485 	callInfo.iCallName = callName;

   486     completeCallInfoData.SerialiseL(data);

   487     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   488 	User::WaitForRequest(mockLtsyStatus);

   489 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   490 	

   491 	ChangeCallStatusL(KCallId1 , KMobileService, RMobileCall::EStatusDialling);

   492 

   493 	data.Close();

   494 	expHangUpData.SerialiseL(data);

   495     iMockLTSY.ExpectL(EEtelCallHangUp, data, KErrNone);

   496 

   497     data.Close();

   498     mobileCallStatus = RMobileCall::EStatusIdle;

   499     completeCallStatusData.SerialiseL(data);

   500     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, hangUpCause, data);

   501 

   502 	mobileCall3.CancelAsyncRequest(EMobileCallDialEmergencyCall);

   503 	

   504 	User::WaitForRequest(reqStatus);

   505 	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   506 

   507 	CleanupStack::PopAndDestroy(&mobileCall3);

   508 	AssertMockLtsyStatusL();

   509 

   510 	//-------------------------------------------------------------------------

   511 	// Test cancelling of RMobileCall::DialEmergencyCall

   512 	// after call status is changed to connecting

   513  	//-------------------------------------------------------------------------

   514 

   515 	RMobileCall mobileCall4;

   516 	err = mobileCall4.OpenNewCall(line, callName);

   517 	ASSERT_EQUALS(KErrNone, err);

   518 	CleanupClosePushL(mobileCall4);

   519 

   520     data.Close();

   521 	numberLtsyData.SerialiseL(data);

   522 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   523 

   524 	mobileCall4.DialEmergencyCall(reqStatus, number);

   525 

   526 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   527     data.Close();

   528 	callInfo.iCallName = callName;

   529     completeCallInfoData.SerialiseL(data);

   530     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   531 	User::WaitForRequest(mockLtsyStatus);

   532 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   533 	

   534 	ChangeCallStatusL(KCallId1 , KMobileService, RMobileCall::EStatusDialling);

   535 	ChangeCallStatusL(KCallId1 , KMobileService, RMobileCall::EStatusConnecting);

   536 

   537 	data.Close();

   538 	expHangUpData.SerialiseL(data);

   539     iMockLTSY.ExpectL(EEtelCallHangUp, data, KErrNone);

   540 

   541     data.Close();

   542     mobileCallStatus = RMobileCall::EStatusDisconnecting;

   543     completeCallStatusData.SerialiseL(data);

   544     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, hangUpCause, data);

   545 

   546     data.Close();

   547     mobileCallStatus = RMobileCall::EStatusIdle;

   548     completeCallStatusData.SerialiseL(data);

   549     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, hangUpCause, data);

   550 

   551 	mobileCall4.CancelAsyncRequest(EMobileCallDialEmergencyCall);

   552 	

   553 	User::WaitForRequest(reqStatus);

   554 	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   555 

   556 	CleanupStack::PopAndDestroy(&mobileCall4);

   557 	AssertMockLtsyStatusL();

   558 	CleanupStack::PopAndDestroy(3, this); // line, data, this

   559 	

   560 	}

   561 

   562 

   563 /**

   564 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0003

   565 @SYMComponent  telephony_ctsy

   566 @SYMTestCaseDesc Test support in CTSY for RMobileCall::DialEmergencyCall with bad parameter data for voice calls

   567 @SYMTestPriority High

   568 @SYMTestActions Invokes RMobileCall::DialEmergencyCall with bad parameter data for voice calls

   569 @SYMTestExpectedResults Pass

   570 @SYMTestType CT

   571 */

   572 void CCTsyCallEmergencyFU::TestDialEmergencyCall0003L()

   573 	{

   574 

   575 	OpenEtelServerL(EUseExtendedError);

   576 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   577 	OpenPhoneL();

   578 

   579 	RBuf8 data;

   580 	CleanupClosePushL(data);

   581 

   582 	RLine line;

   583 	TInt err = line.Open(iPhone, KMmTsyVoice1LineName);

   584 	ASSERT_EQUALS(KErrNone, err)

   585     CleanupClosePushL(line);

   586 	

   587 	TRequestStatus reqStatus;

   588 

   589 	RMobileCall mobileCall;

   590 	err = mobileCall.OpenNewCall(line);

   591 	ASSERT_EQUALS(KErrNone, err);

   592 	CleanupClosePushL(mobileCall);

   593 

   594 	//-------------------------------------------------------------------------

   595 	// Test B: Test passing wrong descriptor size to parameter in

   596 	// RMobileCall::DialEmergencyCall

   597  	//-------------------------------------------------------------------------

   598 

   599 	RMobileENStore::TEmergencyNumber number(KNullDesC);

   600 	TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData(number);

   601 	numberLtsyData.SerialiseL(data);

   602 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrArgument);

   603 

   604 	TBuf<1> bufNumber(KNullDesC);

   605 	mobileCall.DialEmergencyCall(reqStatus, bufNumber);

   606 	User::WaitForRequest(reqStatus);

   607 	AssertMockLtsyStatusL();

   608 	ASSERT_EQUALS(KErrArgument, reqStatus.Int());

   609 

   610 	TBuf<7> emergNumber = _L("9111120");

   611 	mobileCall.DialEmergencyCall(reqStatus, emergNumber);

   612 	User::WaitForRequest(reqStatus);

   613 	AssertMockLtsyStatusL();

   614 	ASSERT_EQUALS(KErrArgument, reqStatus.Int());

   615 	

   616 	CleanupStack::PopAndDestroy(4, this); // mobileCall, line, data, this

   617 	}

   618 

   619 

   620 /**

   621 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0004

   622 @SYMComponent  telephony_ctsy

   623 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::DialEmergencyCall for voice calls

   624 @SYMTestPriority High

   625 @SYMTestActions Invokes multiple client requests to RMobileCall::DialEmergencyCall for voice calls

   626 @SYMTestExpectedResults Pass

   627 @SYMTestType CT

   628 */

   629 void CCTsyCallEmergencyFU::TestDialEmergencyCall0004L()

   630 	{

   631 

   632 	OpenEtelServerL(EUseExtendedError);

   633 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   634 	OpenPhoneL();

   635 

   636 	RBuf8 data;

   637 	CleanupClosePushL(data);

   638 

   639 	RLine line;

   640 	TInt err = line.Open(iPhone, KMmTsyVoice1LineName);

   641 	ASSERT_EQUALS(KErrNone, err)

   642     CleanupClosePushL(line);

   643 	

   644 	TRequestStatus reqStatus;

   645 

   646 	RMobileCall mobileCall;

   647 	TName callName;

   648 	err = mobileCall.OpenNewCall(line, callName);

   649 	ASSERT_EQUALS(KErrNone, err);

   650 	CleanupClosePushL(mobileCall);

   651 

   652 	RMobileENStore::TEmergencyNumber number(_L("911"));

   653 	TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData(number);

   654 	RMobileENStore::TEmergencyNumber number2(_L("112"));

   655 	TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData2(number2);

   656 

   657 	const RMobilePhone::TMobileService KMobileService = RMobilePhone::EVoiceService;

   658 	const TInt KCallId = 1;

   659 	const TInt KCallId2 = 2;

   660 

   661 	RMobileCall::TMobileCallInfoV1 completeDialCallInfo;

   662 	completeDialCallInfo.iService = KMobileService;

   663 	completeDialCallInfo.iStatus = RMobileCall::EStatusIdle;

   664 	completeDialCallInfo.iCallId = KCallId;

   665 	completeDialCallInfo.iCallName = callName;

   666 	completeDialCallInfo.iLineName = KMmTsyVoice1LineName;

   667 	completeDialCallInfo.iValid = RMobileCall::KCallId;

   668 	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeDialCallInfoData(KCallId, KMobileService, completeDialCallInfo);

   669 

   670 	RMobileCall::TMobileCallInfoV1 callInfo;

   671 	FillInEmergencyCallInfo(callInfo, KCallId, callName, KMobileService);

   672 	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData(KCallId, KMobileService, callInfo);

   673 	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData2(KCallId2, KMobileService, callInfo);

   674 	

   675 	RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle;

   676 	TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData(KCallId, KMobileService, mobileCallStatus);

   677 	TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData2(KCallId2, KMobileService, mobileCallStatus);

   678 

   679 	//-------------------------------------------------------------------------

   680 	// Test requesting RMobileCall::DialEmergencyCall 

   681 	// when pending RCall::Dial

   682  	//-------------------------------------------------------------------------

   683 

   684 	// create pending dial request

   685 	RMobileCall::TMobileCallParamsV1 expDialCallParams;

   686 	expDialCallParams.iInterval = 0;

   687 	expDialCallParams.iCug.iCugIndex = 0xFFFF;

   688 	expDialCallParams.iSpeakerControl = 

   689         RCall::EMonitorSpeakerControlOnUntilCarrier;

   690 	expDialCallParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;

   691 	expDialCallParams.iWaitForDialTone = RCall::EDialToneWait;

   692 	expDialCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

   693 	expDialCallParams.iCug.iExplicitInvoke = EFalse;

   694 	expDialCallParams.iCug.iSuppressPrefCug = EFalse;

   695 	expDialCallParams.iCug.iSuppressOA = EFalse;

   696 	expDialCallParams.iAutoRedial = EFalse;

   697 	

   698     

   699 	RMobileCall::TMobileCallInfoV8 expDialCallInfo;

   700 	_LIT(KPhoneNumber, "101632960000");   	

   701 	expDialCallInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber);

   702 	expDialCallInfo.iService = KMobileService;

   703 	expDialCallInfo.iValid = RMobileCall::KCallDialledParty|RMobileCall::KCallAlternating;

   704 	expDialCallInfo.iDialledParty.iNumberPlan = 

   705             RMobilePhone::EUnknownNumberingPlan;

   706 	expDialCallInfo.iDialledParty.iTypeOfNumber = 

   707 	        RMobilePhone::EUnknownNumber;

   708 	expDialCallInfo.iAlternatingCall = 

   709 	        RMobilePhone::EAlternatingModeUnspecified;

   710 

   711 	

   712 	TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> 

   713 		dialExpectData(0, KMobileService, expDialCallParams, expDialCallInfo);

   714 

   715     data.Close();

   716     dialExpectData.SerialiseL(data);

   717 	iMockLTSY.ExpectL(EEtelCallDial, data);

   718 

   719     data.Close();

   720     completeDialCallInfoData.SerialiseL(data);

   721     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data, 10);

   722 

   723     data.Close();

   724     mobileCallStatus = RMobileCall::EStatusDialling;

   725     completeCallStatusData.SerialiseL(data);

   726     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10);

   727 

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

   729 	// Test fails, TEF aborts the test and all the following

   730 	// Actually DialEmergencyCall completes with KErrServerBusy

   731 	

   732 	// following assert is added to prevent test abortions

   733 	ASSERT_TRUE( EFalse );

   734 

   735 	TRequestStatus dialStatus;

   736 	mobileCall.Dial(dialStatus, KPhoneNumber);

   737 

   738 	// prepare test

   739 

   740 	// prepare canceling dial request

   741     data.Close();

   742 	TInt hangUpCause = KErrGsmReleaseByUser;

   743 	TBool autoStChangeDisable = ETrue;

   744     TMockLtsyCallData2<TInt, TBool> expHangupData(KCallId, KMobileService, 

   745                                              hangUpCause, 

   746                                              autoStChangeDisable);

   747     expHangupData.SerialiseL(data);

   748     iMockLTSY.ExpectL(EEtelCallHangUp, data);

   749 

   750     data.Close();

   751     mobileCallStatus = RMobileCall::EStatusIdle;

   752     completeCallStatusData.SerialiseL(data);

   753     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, hangUpCause, data, 10);

   754 

   755 	// prepare dialling emergency call

   756     data.Close();

   757 	numberLtsyData.SerialiseL(data);

   758 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   759 

   760     data.Close();

   761     completeCallInfoData.SerialiseL(data);

   762     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   763 

   764     data.Close();

   765     mobileCallStatus = RMobileCall::EStatusDialling;

   766     completeCallStatusData.SerialiseL(data);

   767     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   768 

   769     data.Close();

   770     mobileCallStatus = RMobileCall::EStatusConnecting;

   771     completeCallStatusData.SerialiseL(data);

   772     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   773 

   774     data.Close();

   775     mobileCallStatus = RMobileCall::EStatusConnected;

   776     completeCallStatusData.SerialiseL(data);

   777     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   778 

   779 	// actual test

   780 	mobileCall.DialEmergencyCall(reqStatus, number);

   781 

   782 	User::WaitForRequest(dialStatus);

   783 	ASSERT_EQUALS(KErrCancel, dialStatus.Int());

   784 

   785 	User::WaitForRequest(reqStatus);

   786 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   787 

   788 	PrepareCallCloseL(KCallId, KMobileService);

   789 	CleanupStack::PopAndDestroy(&mobileCall);

   790 	AssertMockLtsyStatusL();

   791 

   792 	//-------------------------------------------------------------------------

   793 	// Test A: Test multiple clients requesting RMobileCall::DialEmergencyCall

   794  	//-------------------------------------------------------------------------

   795 

   796 	err = mobileCall.OpenNewCall(line, callName);

   797 	ASSERT_EQUALS(KErrNone, err);

   798 	CleanupClosePushL(mobileCall);

   799 

   800 	// Open second client

   801 	RTelServer telServer2;

   802 	err = telServer2.Connect();

   803 	ASSERT_EQUALS(KErrNone, err);

   804 	CleanupClosePushL(telServer2);

   805 

   806 	RMobilePhone phone2;

   807 	err = phone2.Open(telServer2, KMmTsyPhoneName);

   808 	ASSERT_EQUALS(KErrNone, err);

   809 	CleanupClosePushL(phone2);

   810 

   811 	RLine line2;

   812 	err = line2.Open(phone2, KMmTsyVoice1LineName);

   813 	ASSERT_EQUALS(KErrNone, err)

   814     CleanupClosePushL(line2);

   815 	

   816 	RMobileCall mobileCall2;

   817 	TName callName2;

   818 	err = mobileCall2.OpenNewCall(line2, callName2);

   819 	ASSERT_EQUALS(KErrNone, err);

   820 	CleanupClosePushL(mobileCall2);

   821 

   822 	data.Close();

   823 	numberLtsyData.SerialiseL(data);

   824 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   825 

   826 	mobileCall.DialEmergencyCall(reqStatus, number);

   827 

   828 	data.Close();

   829 	numberLtsyData2.SerialiseL(data);

   830 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   831 

   832 	data.Close();

   833     callInfo.iCallName = callName;

   834     completeCallInfoData.SerialiseL(data);

   835     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   836     data.Close();

   837     callInfo.iCallId = KCallId2;

   838     callInfo.iCallName = callName2;

   839     completeCallInfoData2.SerialiseL(data);

   840     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   841 

   842     data.Close();

   843     mobileCallStatus = RMobileCall::EStatusDialling;

   844     completeCallStatusData.SerialiseL(data);

   845     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   846     data.Close();

   847     completeCallStatusData2.SerialiseL(data);

   848     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   849 

   850     data.Close();

   851     mobileCallStatus = RMobileCall::EStatusConnecting;

   852     completeCallStatusData.SerialiseL(data);

   853     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   854     data.Close();

   855     completeCallStatusData2.SerialiseL(data);

   856     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   857 

   858     data.Close();

   859     mobileCallStatus = RMobileCall::EStatusConnected;

   860     completeCallStatusData.SerialiseL(data);

   861     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   862     data.Close();

   863     completeCallStatusData2.SerialiseL(data);

   864     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   865 

   866 	ASSERT_EQUALS(KRequestPending, reqStatus.Int());

   867 	TRequestStatus reqStatus2;

   868 	mobileCall2.DialEmergencyCall(reqStatus2, number2);

   869 

   870 	User::WaitForRequest(reqStatus);

   871 	User::WaitForRequest(reqStatus2);

   872 	AssertMockLtsyStatusL();

   873 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

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

   875 	// Second completion with EMobileCallGetMobileCallInfo ipc

   876 	// changes callid of 1st call from 1 to 2

   877 	// can not invoke completions for 2nd call 

   878 	ASSERT_EQUALS(KErrNone, reqStatus2.Int()); // KErrTimedOut

   879 

   880 	// Done !

   881 	CleanupStack::PopAndDestroy(8, this); // mobileCall2, line2, phone2, telServer2, mobileCall, line, data, this

   882 

   883 	}

   884 

   885 

   886 /**

   887 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0005

   888 @SYMComponent  telephony_ctsy

   889 @SYMTestCaseDesc Test support in CTSY for RMobileCall::DialEmergencyCall with timeout for voice calls

   890 @SYMTestPriority High

   891 @SYMTestActions Invokes RMobileCall::DialEmergencyCall and tests for timeout for voice calls

   892 @SYMTestExpectedResults Pass

   893 @SYMTestType CT

   894 */

   895 void CCTsyCallEmergencyFU::TestDialEmergencyCall0005L()

   896 	{

   897 

   898 	OpenEtelServerL(EUseExtendedError);

   899 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   900 	OpenPhoneL();

   901 

   902 	RBuf8 data;

   903 	CleanupClosePushL(data);

   904 

   905 	RLine line;

   906 	TInt err = line.Open(iPhone, KMmTsyVoice1LineName);

   907 	ASSERT_EQUALS(KErrNone, err)

   908 	CleanupClosePushL(line);

   909 	

   910 	RMobileCall mobileCall;

   911 	TName callName;

   912 	err = mobileCall.OpenNewCall(line, callName);

   913 	ASSERT_EQUALS(KErrNone, err);

   914 	CleanupClosePushL(mobileCall);

   915 

   916 	//-------------------------------------------------------------------------

   917 	// Test A: Test timeout of RMobileCall::DialEmergencyCall

   918  	//-------------------------------------------------------------------------

   919 

   920 	RMobileENStore::TEmergencyNumber number(_L("911"));

   921 	TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData(number);

   922 	numberLtsyData.SerialiseL(data);

   923 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   924 

   925 	TRequestStatus reqStatus;

   926 	mobileCall.DialEmergencyCall(reqStatus, number);

   927 	User::WaitForRequest(reqStatus);

   928 	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

   929 

   930 	AssertMockLtsyStatusL();

   931 

   932 	//-------------------------------------------------------------------------

   933 	// Test: Test timeout of RMobileCall::DialEmergencyCall

   934 	// when callId is changed

   935  	//-------------------------------------------------------------------------

   936 

   937 	data.Close();

   938 	numberLtsyData.SerialiseL(data);

   939 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   940 

   941 	const RMobilePhone::TMobileService KMobileService = RMobilePhone::EVoiceService;

   942 	const TInt KCallId = 1;

   943 	RMobileCall::TMobileCallInfoV1 callInfo;

   944 	FillInEmergencyCallInfo(callInfo, KCallId, callName, KMobileService);

   945 	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData(KCallId, KMobileService, callInfo);

   946 	data.Close();

   947 	completeCallInfoData.SerialiseL(data);

   948 	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   949 

   950 	mobileCall.DialEmergencyCall(reqStatus, number);

   951 	User::WaitForRequest(reqStatus);

   952 	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

   953 

   954 	AssertMockLtsyStatusL();

   955 

   956 	//-------------------------------------------------------------------------

   957 	// Test: Test timeout of RMobileCall::DialEmergencyCall

   958 	// when call status is changed to RMobileCall::EStatusDialling

   959  	//-------------------------------------------------------------------------

   960 

   961 	data.Close();

   962 	numberLtsyData.SerialiseL(data);

   963 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   964 

   965 	data.Close();

   966 	completeCallInfoData.SerialiseL(data);

   967 	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   968 

   969 	RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusDialling;

   970 	TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData(KCallId, KMobileService, mobileCallStatus);

   971 	data.Close();

   972 	completeCallStatusData.SerialiseL(data);

   973 	iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   974 

   975 	mobileCall.DialEmergencyCall(reqStatus, number);

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

   977 	// TEF aborts the test

   978 	User::WaitForRequest(reqStatus);

   979 	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

   980 

   981 	AssertMockLtsyStatusL();

   982 

   983 	//-------------------------------------------------------------------------

   984 	// Test: Test timeout of RMobileCall::DialEmergencyCall

   985 	// when call status is changed to RMobileCall::EStatusConnecting

   986  	//-------------------------------------------------------------------------

   987 

   988 	data.Close();

   989 	numberLtsyData.SerialiseL(data);

   990 	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   991 

   992 	data.Close();

   993 	completeCallInfoData.SerialiseL(data);

   994 	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   995 

   996 	data.Close();

   997 	mobileCallStatus = RMobileCall::EStatusDialling;

   998 	completeCallStatusData.SerialiseL(data);

   999 	iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

  1000 

  1001 	data.Close();

  1002 	mobileCallStatus = RMobileCall::EStatusConnecting;

  1003 	completeCallStatusData.SerialiseL(data);

  1004 	iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

  1005 

  1006 	mobileCall.DialEmergencyCall(reqStatus, number);

  1007 	User::WaitForRequest(reqStatus);

  1008 	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

  1009 

  1010 	AssertMockLtsyStatusL();

  1011 

  1012 	CleanupStack::PopAndDestroy(2); // mobileCall, line

  1013 	CleanupStack::PopAndDestroy(2, this); // data, this

  1014 

  1015 	}

  1016 

  1017 

  1018 /**

  1019 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0001b

  1020 @SYMComponent  telephony_ctsy

  1021 @SYMTestCaseDesc Test support in CTSY for RMobileCall::DialEmergencyCall for data calls

  1022 @SYMTestPriority High

  1023 @SYMTestActions Invokes RMobileCall::DialEmergencyCall for data calls

  1024 @SYMTestExpectedResults Pass

  1025 @SYMTestType CT

  1026 */

  1027 void CCTsyCallEmergencyFU::TestDialEmergencyCall0001bL()

  1028 	{

  1029 

  1030 	OpenEtelServerL(EUseExtendedError);

  1031 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

  1032 	OpenPhoneL();

  1033 

  1034  	//-------------------------------------------------------------------------

  1035 	// TEST C: Successful completion request of

  1036 	// RMobileCall::DialEmergencyCall.

  1037  	//-------------------------------------------------------------------------

  1038 

  1039 	RMobileCall mobileCall;

  1040 	RLine line;

  1041 

  1042 	TInt err = line.Open(iPhone, KMmTsyDataLineName);

  1043 	ASSERT_EQUALS(KErrNone, err)

  1044     CleanupClosePushL(line);

  1045 	

  1046 	err = OpenNewCall(line, mobileCall, KMmTsyDataLineName);

  1047 	ASSERT_EQUALS(KErrNone, err)

  1048     CleanupClosePushL(mobileCall);

  1049 

  1050 	TRequestStatus reqStatus;

  1051 	RMobileENStore::TEmergencyNumber number(_L("911"));

  1052 	mobileCall.DialEmergencyCall(reqStatus, number);

  1053 	User::WaitForRequest(reqStatus);

  1054 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

  1055 	AssertMockLtsyStatusL();

  1056 

  1057 	CleanupStack::PopAndDestroy(2); // mobileCall, line

  1058 	CleanupStack::PopAndDestroy(this);

  1059 	

  1060 	}

  1061 

  1062 

  1063 /**

  1064 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0001c

  1065 @SYMComponent  telephony_ctsy

  1066 @SYMTestCaseDesc Test support in CTSY for RMobileCall::DialEmergencyCall for fax calls

  1067 @SYMTestPriority High

  1068 @SYMTestActions Invokes RMobileCall::DialEmergencyCall for fax calls

  1069 @SYMTestExpectedResults Pass

  1070 @SYMTestType CT

  1071 */

  1072 void CCTsyCallEmergencyFU::TestDialEmergencyCall0001cL()

  1073 	{

  1074 

  1075 	OpenEtelServerL(EUseExtendedError);

  1076 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

  1077 	OpenPhoneL();

  1078 

  1079  	//-------------------------------------------------------------------------

  1080 	// TEST C: Successful completion request of

  1081 	// RMobileCall::DialEmergencyCall.

  1082  	//-------------------------------------------------------------------------

  1083 

  1084 	RMobileCall mobileCall;

  1085 	RLine line;

  1086 

  1087 	TInt err = line.Open(iPhone, KMmTsyFaxLineName);

  1088 	ASSERT_EQUALS(KErrNone, err)

  1089     CleanupClosePushL(line);

  1090 	

  1091 	err = OpenNewCall(line, mobileCall, KMmTsyFaxLineName);

  1092 	ASSERT_EQUALS(KErrNone, err)

  1093     CleanupClosePushL(mobileCall);

  1094 

  1095 	TRequestStatus reqStatus;

  1096 	RMobileENStore::TEmergencyNumber number(_L("911"));

  1097 	mobileCall.DialEmergencyCall(reqStatus, number);

  1098 	User::WaitForRequest(reqStatus);

  1099 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

  1100 	AssertMockLtsyStatusL();

  1101 

  1102 	CleanupStack::PopAndDestroy(2); // mobileCall, line

  1103 	CleanupStack::PopAndDestroy(this);

  1104 	

  1105 	}

  1106 

  1107 /**

  1108 @SYMTestCaseID BA-CTSY-CEMG-CDEC-0001d

  1109 @SYMComponent  telephony_ctsy

  1110 @SYMTestCaseDesc Test support in CTSY for RMobileCall::DialEmergencyCall for voice calls

  1111 @SYMTestPriority High

  1112 @SYMTestActions Invokes RMobileCall::DialEmergencyCall for voice calls. It tests differen answers from SSMPlugin

  1113 @SYMTestExpectedResults Pass

  1114 @SYMTestType CT

  1115 */

  1116 void CCTsyCallEmergencyFU::TestDialEmergencyCall0001dL()

  1117 	{

  1118 	// if there is no SSM it means that we use SSMStub -> we can use RProperty for emulation   

  1119 #ifndef SYMBIAN_SYSTEM_STATE_MANAGEMENT    

  1120 

  1121 	OpenEtelServerL(EUseExtendedError);

  1122 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

  1123 	OpenPhoneL();

  1124 

  1125 	RBuf8 data;

  1126 	CleanupClosePushL(data);

  1127 

  1128 	RLine line;

  1129 	TInt err = line.Open(iPhone, KMmTsyVoice1LineName);

  1130 	ASSERT_EQUALS(KErrNone, err)

  1131     CleanupClosePushL(line);

  1132 	

  1133 	TRequestStatus reqStatus;

  1134