|
1 // Copyright (c) 2008-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 TelephonyAudioControl in the Common TSY. |
|
15 // |
|
16 // |
|
17 |
|
18 #include "cctsytelephonyaudiocontrolfu.h" |
|
19 #include <etel.h> |
|
20 #include <etelmm.h> |
|
21 #include <ctsy/mmtsy_names.h> |
|
22 #include <et_clsvr.h> |
|
23 #include <ctsy/serviceapi/mmtsy_ipcdefs.h> |
|
24 #include <e32property.h> |
|
25 #include "tmockltsydata.h" |
|
26 #include <ctsy/serviceapi/gsmerror.h> |
|
27 #include <ctsy/pluginapi/mtelephonyaudiocontrol.h> |
|
28 |
|
29 _LIT( KPhoneNumber, "101632960000" ); |
|
30 |
|
31 CTestSuite* CCTsyTelephonyAudioControlFU::CreateSuiteL(const TDesC& aName) |
|
32 { |
|
33 SUB_SUITE; |
|
34 |
|
35 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0001aL); |
|
36 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0001bL); |
|
37 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0004L); |
|
38 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0001aL); |
|
39 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0001bL); |
|
40 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0004L); |
|
41 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0001aL); |
|
42 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0001bL); |
|
43 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0004L); |
|
44 ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestNotifyTelephonyAudioControlError0001L ); |
|
45 |
|
46 END_SUITE; |
|
47 } |
|
48 |
|
49 // |
|
50 // Actual test cases |
|
51 // |
|
52 |
|
53 |
|
54 /** |
|
55 @SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0001a |
|
56 @SYMComponent telephony_ctsy |
|
57 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::SetUpCallRouting |
|
58 @SYMTestPriority High |
|
59 @SYMTestActions Invokes MTelephonyAudioControl::SetUpCallRouting |
|
60 @SYMTestExpectedResults Pass |
|
61 @SYMTestType CT |
|
62 */ |
|
63 void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0001aL() |
|
64 { |
|
65 DefinePropeties( ETrue, EVersion2 ); |
|
66 |
|
67 OpenEtelServerL(EUseExtendedError); |
|
68 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
69 OpenPhoneL(); |
|
70 |
|
71 RBuf8 data; |
|
72 CleanupClosePushL(data); |
|
73 |
|
74 RBuf8 expectData; |
|
75 CleanupClosePushL(expectData); |
|
76 |
|
77 RBuf8 completeData; |
|
78 CleanupClosePushL(completeData); |
|
79 |
|
80 TRequestStatus status( KErrNone ); |
|
81 TInt callId( 1 ); |
|
82 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
83 RMobileCall::TMobileCallParamsV7 callParams; |
|
84 RMobileCall::TMobileCallInfoV8 callInfo; |
|
85 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
86 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
87 callParams.iInterval = 100; |
|
88 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
89 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
90 callParams.iCug.iExplicitInvoke = EFalse; |
|
91 callParams.iCug.iCugIndex = 0xFFFF; |
|
92 callParams.iCug.iSuppressPrefCug = EFalse; |
|
93 callParams.iCug.iSuppressOA = EFalse; |
|
94 callParams.iAutoRedial = EFalse; |
|
95 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
96 callInfo.iService = mobileService; |
|
97 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
98 callInfo.iCallId =-1; |
|
99 callInfo.iExitCode =0; |
|
100 callInfo.iEmergency =0; |
|
101 callInfo.iForwarded =0; |
|
102 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
103 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
104 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
105 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
106 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
107 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
108 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
109 |
|
110 RCall::TCallParams callParamsX1; |
|
111 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
112 |
|
113 TRequestStatus mockLtsyStatus( KErrNone ); |
|
114 RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting ); |
|
115 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus ); |
|
116 |
|
117 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
118 TBool autoStChangeDisable ( EFalse ); |
|
119 |
|
120 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
121 |
|
122 RLine line; |
|
123 RMobileCall call; |
|
124 |
|
125 //------------------------------------------------------------------------- |
|
126 // TEST C: Successful completion request of |
|
127 // MTelephonyAudioControl::SetUpCallRouting when result is not cached. |
|
128 //------------------------------------------------------------------------- |
|
129 |
|
130 // DialL |
|
131 |
|
132 // reset the properties to ensure to get valid data |
|
133 DefinePropeties( ETrue, EVersion2 ); |
|
134 |
|
135 // reset line & call |
|
136 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
137 CleanupClosePushL( line ); |
|
138 ASSERT_EQUALS( KErrNone, error ); |
|
139 |
|
140 error = call.OpenNewCall( line ); |
|
141 CleanupClosePushL( call ); |
|
142 ASSERT_EQUALS( KErrNone, error ); |
|
143 |
|
144 // prepare MockLTSY |
|
145 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
146 mockData2.SerialiseL(expectData); |
|
147 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
148 mockData0.SerialiseL(completeData); |
|
149 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
150 |
|
151 // make the call |
|
152 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
153 User::WaitForRequest( status ); |
|
154 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
155 |
|
156 // check that values passed to the SetupCallRouting were valid |
|
157 CheckCallRoutingValues( line, call ); |
|
158 |
|
159 // cleanup |
|
160 AssertMockLtsyStatusL(); |
|
161 CleanupStack::PopAndDestroy( &call ); |
|
162 CleanupStack::PopAndDestroy( &line ); |
|
163 |
|
164 // DialNoFdnCheck |
|
165 |
|
166 // reset line and call |
|
167 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
168 CleanupClosePushL( line ); |
|
169 ASSERT_EQUALS( KErrNone, error ); |
|
170 |
|
171 error = call.OpenNewCall( line ); |
|
172 CleanupClosePushL( call ); |
|
173 ASSERT_EQUALS( KErrNone, error ); |
|
174 |
|
175 // prepare MockLTSY |
|
176 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
177 expectData.Close(); |
|
178 mockData2.SerialiseL(expectData); |
|
179 iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData); |
|
180 completeData.Close(); |
|
181 mockData0.SerialiseL(completeData); |
|
182 iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData); |
|
183 |
|
184 // make the call |
|
185 call.DialNoFdnCheck( status, pckgCallParamsX1, KPhoneNumber ); |
|
186 User::WaitForRequest( status ); |
|
187 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
188 |
|
189 // check that values passed to the SetupCallRouting were valid |
|
190 CheckCallRoutingValues( line, call ); |
|
191 |
|
192 // cleanup |
|
193 AssertMockLtsyStatusL(); |
|
194 CleanupStack::PopAndDestroy( &call ); |
|
195 CleanupStack::PopAndDestroy( &line ); |
|
196 AssertMockLtsyStatusL(); |
|
197 |
|
198 // DialISV |
|
199 |
|
200 // reset the properties to ensure to get valid data |
|
201 DefinePropeties( ETrue, EVersion2 ); |
|
202 |
|
203 // reset line and call |
|
204 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
205 CleanupClosePushL( line ); |
|
206 ASSERT_EQUALS( KErrNone, error ); |
|
207 |
|
208 error = call.OpenNewCall( line ); |
|
209 CleanupClosePushL( call ); |
|
210 ASSERT_EQUALS( KErrNone, error ); |
|
211 |
|
212 // prepare MockLTSY |
|
213 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
214 expectData.Close(); |
|
215 mockData2.SerialiseL(expectData); |
|
216 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
217 completeData.Close(); |
|
218 mockData0.SerialiseL(completeData); |
|
219 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
220 |
|
221 call.DialISV( status, pckgCallParamsX1, KPhoneNumber ); |
|
222 User::WaitForRequest( status ); |
|
223 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
224 |
|
225 // check that values passed to the SetupCallRouting were valid |
|
226 CheckCallRoutingValues( line, call ); |
|
227 |
|
228 // cleanup |
|
229 AssertMockLtsyStatusL(); |
|
230 CleanupStack::PopAndDestroy( &call ); |
|
231 CleanupStack::PopAndDestroy( &line ); |
|
232 AssertMockLtsyStatusL(); |
|
233 |
|
234 // Ghost Call |
|
235 |
|
236 // reset the properties to ensure to get valid data |
|
237 DefinePropeties( ETrue, EVersion2 ); |
|
238 |
|
239 // reset line |
|
240 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
241 CleanupClosePushL( line ); |
|
242 ASSERT_EQUALS( KErrNone, error ); |
|
243 |
|
244 // order NotifyStatusChange event |
|
245 RCall::TStatus callStatus( RCall::EStatusIdle ); |
|
246 line.NotifyStatusChange( status, callStatus ); |
|
247 |
|
248 // prepare MockLTSY for NotifyStatusChange event |
|
249 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
250 RMobileCall::TMobileCallInfoV1 mobileCallInfo; |
|
251 mobileCallInfo.iCallId = callId; |
|
252 mobileCallInfo.iService = mobileService; |
|
253 mobileCallInfo.iStatus = RMobileCall::EStatusDialling; |
|
254 mobileCallInfo.iCallName.Copy( _L8("Voice12") ); |
|
255 |
|
256 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo); |
|
257 mockCallData1.SerialiseL(data); |
|
258 iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data); |
|
259 |
|
260 User::WaitForRequest(mockLtsyStatus); |
|
261 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
262 User::WaitForRequest(status); |
|
263 ASSERT_EQUALS(KErrNone, status.Int()); |
|
264 ASSERT_EQUALS(RCall::EStatusDialling, callStatus); |
|
265 |
|
266 error = call.OpenExistingCall( line, mobileCallInfo.iCallName ); |
|
267 CleanupClosePushL( call ); |
|
268 ASSERT_EQUALS( KErrNone, error ); |
|
269 |
|
270 data.Close(); |
|
271 completeCallStatusData.SerialiseL(data); |
|
272 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); |
|
273 |
|
274 call.NotifyMobileCallStatusChange( status, mobileCallStatus ); |
|
275 User::WaitForRequest( status ); |
|
276 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
277 |
|
278 AssertMockLtsyStatusL(); |
|
279 |
|
280 CheckCallStatus( mobileCallInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
281 |
|
282 // prepare MockLTSY for hangup |
|
283 expectData.Close(); |
|
284 mockHangUpData.SerialiseL(expectData); |
|
285 iMockLTSY.ExpectL( EEtelCallHangUp, expectData, KErrNone ); |
|
286 |
|
287 // hangup the call by popping the call from the cleanupstack |
|
288 CleanupStack::PopAndDestroy( &call ); |
|
289 AssertMockLtsyStatusL(); |
|
290 |
|
291 CleanupStack::PopAndDestroy( &line ); |
|
292 AssertMockLtsyStatusL(); |
|
293 |
|
294 // DialEmergencyCall |
|
295 |
|
296 // reset the properties to ensure to get valid data |
|
297 DefinePropeties( ETrue, EVersion2 ); |
|
298 |
|
299 // reset line and call |
|
300 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
301 CleanupClosePushL( line ); |
|
302 ASSERT_EQUALS( KErrNone, error ); |
|
303 |
|
304 error = call.OpenNewCall( line ); |
|
305 CleanupClosePushL( call ); |
|
306 ASSERT_EQUALS( KErrNone, error ); |
|
307 |
|
308 // set rf on |
|
309 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
310 TRfStateInfo rfInfo = ERfsStateInfoNormal; |
|
311 TMockLtsyData1<TRfStateInfo> mockData1( rfInfo ); |
|
312 expectData.Close(); |
|
313 mockData1.SerialiseL(expectData); |
|
314 iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData); |
|
315 User::WaitForRequest(mockLtsyStatus); |
|
316 AssertMockLtsyStatusL(); |
|
317 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
318 |
|
319 // the emergency number |
|
320 RMobileENStore::TEmergencyNumber number(_L("911")); |
|
321 TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData( number ); |
|
322 |
|
323 CallGetMobileCallInfoL(callId, mobileService, number ); |
|
324 |
|
325 // prepare MockLTSY for EMobileCallDialEmergencyCall |
|
326 data.Close(); |
|
327 numberLtsyData.SerialiseL(data); |
|
328 iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone); |
|
329 |
|
330 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData( callId, mobileService, callInfo ); |
|
331 |
|
332 // send EStatusDialling, EStatusConnecting and EStatusConnected events to complete DialEmergencyCall |
|
333 data.Close(); |
|
334 completeCallInfoData.SerialiseL(data); |
|
335 iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data); |
|
336 |
|
337 mobileCallStatus = RMobileCall::EStatusDialling; |
|
338 completeCallStatusData.SerialiseL(data); |
|
339 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); |
|
340 |
|
341 data.Close(); |
|
342 mobileCallStatus = RMobileCall::EStatusConnecting; |
|
343 completeCallStatusData.SerialiseL(data); |
|
344 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); |
|
345 |
|
346 data.Close(); |
|
347 mobileCallStatus = RMobileCall::EStatusConnected; |
|
348 completeCallStatusData.SerialiseL(data); |
|
349 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); |
|
350 |
|
351 // On return, KErrNone if the emergency call successfully reaches the connected state. |
|
352 call.DialEmergencyCall( status, number ); |
|
353 User::WaitForRequest( status ); |
|
354 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
355 |
|
356 // check that values passed to the SetupCallRouting were valid |
|
357 CheckCallRoutingValues( line, call ); |
|
358 |
|
359 // prepare MockLTSY for hangup |
|
360 expectData.Close(); |
|
361 mockHangUpData.SerialiseL(expectData); |
|
362 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
363 |
|
364 // hangup the call by popping the call from the cleanupstack |
|
365 CleanupStack::PopAndDestroy( &call ); |
|
366 AssertMockLtsyStatusL(); |
|
367 |
|
368 // cleanup |
|
369 CleanupStack::PopAndDestroy( &line ); |
|
370 AssertMockLtsyStatusL(); |
|
371 |
|
372 // answer incoming call |
|
373 |
|
374 // reset the properties to ensure to get valid data |
|
375 DefinePropeties( ETrue, EVersion2 ); |
|
376 |
|
377 // reset line |
|
378 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
379 CleanupClosePushL( line ); |
|
380 ASSERT_EQUALS( KErrNone, error ); |
|
381 |
|
382 TName incomingCallName; |
|
383 TRequestStatus requestNotify( KErrNone ); |
|
384 line.NotifyIncomingCall( status, incomingCallName); |
|
385 |
|
386 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo ); |
|
387 mockCallData.SerialiseL( completeData ); |
|
388 |
|
389 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
390 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
391 User::WaitForRequest( mockLtsyStatus ); |
|
392 |
|
393 AssertMockLtsyStatusL(); |
|
394 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
395 |
|
396 User::WaitForRequest( requestNotify ); |
|
397 AssertMockLtsyStatusL(); |
|
398 ASSERT_EQUALS( KErrNone, requestNotify.Int() ); |
|
399 |
|
400 mobileCallStatus = RMobileCall::EStatusRinging; |
|
401 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus ); |
|
402 completeData.Close(); |
|
403 mockCallData2.SerialiseL(completeData); |
|
404 |
|
405 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
406 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
407 User::WaitForRequest(mockLtsyStatus); |
|
408 AssertMockLtsyStatusL(); |
|
409 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
410 |
|
411 expectData.Close(); |
|
412 mockData0.SerialiseL( expectData ); |
|
413 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
414 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
415 |
|
416 // reset the call |
|
417 error = call.OpenExistingCall( line, incomingCallName ); |
|
418 CleanupClosePushL( call ); |
|
419 ASSERT_EQUALS( KErrNone, error ); |
|
420 |
|
421 // answer the call |
|
422 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
423 User::WaitForRequest( status ); |
|
424 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
425 |
|
426 // check that values passed to the SetupCallRouting were valid |
|
427 CheckCallRoutingValues( line, call ); |
|
428 |
|
429 // prepare MockLTSY for hangup |
|
430 expectData.Close(); |
|
431 mockHangUpData.SerialiseL(expectData); |
|
432 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
433 |
|
434 // hangup the call by popping the call from the cleanupstack |
|
435 CleanupStack::PopAndDestroy( &call ); |
|
436 AssertMockLtsyStatusL(); |
|
437 |
|
438 // cleanup |
|
439 CleanupStack::PopAndDestroy( &line ); |
|
440 AssertMockLtsyStatusL(); |
|
441 |
|
442 // cleanup |
|
443 CleanupStack::PopAndDestroy( &completeData ); |
|
444 CleanupStack::PopAndDestroy( &expectData ); |
|
445 CleanupStack::PopAndDestroy( &data ); |
|
446 CleanupStack::PopAndDestroy( this ); |
|
447 } |
|
448 |
|
449 |
|
450 /** |
|
451 @SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0001b |
|
452 @SYMComponent telephony_ctsy |
|
453 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::SetUpCallRouting by using LTSY version1 |
|
454 @SYMTestPriority High |
|
455 @SYMTestActions Test that call routing is not set up |
|
456 @SYMTestExpectedResults Pass |
|
457 @SYMTestType CT |
|
458 */ |
|
459 void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0001bL() |
|
460 { |
|
461 DefinePropeties( ETrue, EVersion1 ); |
|
462 |
|
463 OpenEtelServerL(EUseExtendedError); |
|
464 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
465 OpenPhoneL(); |
|
466 |
|
467 RBuf8 expectData; |
|
468 CleanupClosePushL(expectData); |
|
469 |
|
470 RBuf8 completeData; |
|
471 CleanupClosePushL(completeData); |
|
472 |
|
473 RBuf8 data; |
|
474 CleanupClosePushL(data); |
|
475 |
|
476 TRequestStatus status( KErrNone ); |
|
477 TInt callId( 1 ); |
|
478 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
479 RMobileCall::TMobileCallParamsV7 callParams; |
|
480 RMobileCall::TMobileCallInfoV8 callInfo; |
|
481 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
482 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
483 callParams.iInterval = 100; |
|
484 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
485 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
486 callParams.iCug.iExplicitInvoke = EFalse; |
|
487 callParams.iCug.iCugIndex = 0xFFFF; |
|
488 callParams.iCug.iSuppressPrefCug = EFalse; |
|
489 callParams.iCug.iSuppressOA = EFalse; |
|
490 callParams.iAutoRedial = EFalse; |
|
491 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
492 callInfo.iService = mobileService; |
|
493 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
494 callInfo.iCallId =-1; |
|
495 callInfo.iExitCode =0; |
|
496 callInfo.iEmergency =0; |
|
497 callInfo.iForwarded =0; |
|
498 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
499 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
500 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
501 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
502 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
503 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
504 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
505 |
|
506 RCall::TCallParams callParamsX1; |
|
507 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
508 |
|
509 RLine line; |
|
510 RMobileCall call; |
|
511 |
|
512 //------------------------------------------------------------------------- |
|
513 // TEST C: Successful completion request of |
|
514 // MTelephonyAudioControl::SetUpCallRouting when result is not cached. |
|
515 //------------------------------------------------------------------------- |
|
516 |
|
517 // Test that CMockLtsyFactoryV1 is used instead of CMockLtsyFactoryV2 |
|
518 |
|
519 // DialL |
|
520 |
|
521 // reset line & call |
|
522 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
523 CleanupClosePushL( line ); |
|
524 ASSERT_EQUALS( KErrNone, error ); |
|
525 |
|
526 error = call.OpenNewCall( line ); |
|
527 CleanupClosePushL( call ); |
|
528 ASSERT_EQUALS( KErrNone, error ); |
|
529 |
|
530 // prepare MockLTSY |
|
531 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
532 mockData2.SerialiseL(expectData); |
|
533 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
534 mockData0.SerialiseL(completeData); |
|
535 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
536 |
|
537 // make the call |
|
538 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
539 User::WaitForRequest( status ); |
|
540 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
541 |
|
542 // check that there is no call routing done |
|
543 CheckNoCallRouting(); |
|
544 |
|
545 // cleanup |
|
546 AssertMockLtsyStatusL(); |
|
547 CleanupStack::PopAndDestroy( &call ); |
|
548 CleanupStack::PopAndDestroy( &line ); |
|
549 |
|
550 // DialNoFdnCheck |
|
551 |
|
552 // reset the properties to ensure to get valid data |
|
553 DefinePropeties( ETrue, EVersion1 ); |
|
554 |
|
555 // reset line and call |
|
556 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
557 CleanupClosePushL( line ); |
|
558 ASSERT_EQUALS( KErrNone, error ); |
|
559 |
|
560 error = call.OpenNewCall( line ); |
|
561 CleanupClosePushL( call ); |
|
562 ASSERT_EQUALS( KErrNone, error ); |
|
563 |
|
564 // prepare MockLTSY |
|
565 |
|
566 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
567 expectData.Close(); |
|
568 mockData2.SerialiseL(expectData); |
|
569 iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData); |
|
570 completeData.Close(); |
|
571 mockData0.SerialiseL(completeData); |
|
572 iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData); |
|
573 |
|
574 // make the call |
|
575 call.DialNoFdnCheck( status, pckgCallParamsX1, KPhoneNumber ); |
|
576 User::WaitForRequest( status ); |
|
577 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
578 |
|
579 // check that there is no call routing done |
|
580 CheckNoCallRouting(); |
|
581 |
|
582 // cleanup |
|
583 AssertMockLtsyStatusL(); |
|
584 CleanupStack::PopAndDestroy( &call ); |
|
585 CleanupStack::PopAndDestroy( &line ); |
|
586 AssertMockLtsyStatusL(); |
|
587 |
|
588 // DialEmergencyCall |
|
589 |
|
590 // reset the properties to ensure to get valid data |
|
591 DefinePropeties( ETrue, EVersion1 ); |
|
592 |
|
593 // reset line and call |
|
594 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
595 CleanupClosePushL( line ); |
|
596 ASSERT_EQUALS( KErrNone, error ); |
|
597 |
|
598 error = call.OpenNewCall( line ); |
|
599 CleanupClosePushL( call ); |
|
600 ASSERT_EQUALS( KErrNone, error ); |
|
601 |
|
602 // set rf on |
|
603 TRequestStatus mockLtsyStatus(KErrNone); |
|
604 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
605 TRfStateInfo rfInfo = ERfsStateInfoNormal; |
|
606 TMockLtsyData1<TRfStateInfo> mockData1( rfInfo ); |
|
607 expectData.Close(); |
|
608 mockData1.SerialiseL(expectData); |
|
609 iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData); |
|
610 User::WaitForRequest(mockLtsyStatus); |
|
611 AssertMockLtsyStatusL(); |
|
612 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
613 |
|
614 // the emergency number |
|
615 RMobileENStore::TEmergencyNumber number(_L("911")); |
|
616 TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData( number ); |
|
617 |
|
618 CallGetMobileCallInfoL(callId, mobileService, number ); |
|
619 |
|
620 // prepare MockLTSY for EMobileCallDialEmergencyCall |
|
621 data.Close(); |
|
622 numberLtsyData.SerialiseL(data); |
|
623 iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone); |
|
624 |
|
625 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData( callId, mobileService, callInfo ); |
|
626 |
|
627 // send EStatusDialling, EStatusConnecting and EStatusConnected events to complete DialEmergencyCall |
|
628 data.Close(); |
|
629 completeCallInfoData.SerialiseL(data); |
|
630 iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data); |
|
631 |
|
632 RMobileCall::TMobileCallStatus mobileCallStatus(RMobileCall::EStatusDialling); |
|
633 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus ); |
|
634 completeCallStatusData.SerialiseL(data); |
|
635 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); |
|
636 |
|
637 data.Close(); |
|
638 mobileCallStatus = RMobileCall::EStatusConnecting; |
|
639 completeCallStatusData.SerialiseL(data); |
|
640 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); |
|
641 |
|
642 data.Close(); |
|
643 mobileCallStatus = RMobileCall::EStatusConnected; |
|
644 completeCallStatusData.SerialiseL(data); |
|
645 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); |
|
646 |
|
647 // On return, KErrNone if the emergency call successfully reaches the connected state. |
|
648 call.DialEmergencyCall( status, number ); |
|
649 User::WaitForRequest( status ); |
|
650 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
651 |
|
652 // check that there is no call routing done |
|
653 CheckNoCallRouting(); |
|
654 |
|
655 // prepare MockLTSY for hangup |
|
656 expectData.Close(); |
|
657 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
658 TBool autoStChangeDisable ( EFalse ); |
|
659 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
660 mockHangUpData.SerialiseL(expectData); |
|
661 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
662 |
|
663 // hangup the call by popping the call from the cleanupstack |
|
664 CleanupStack::PopAndDestroy( &call ); |
|
665 AssertMockLtsyStatusL(); |
|
666 |
|
667 // cleanup |
|
668 CleanupStack::PopAndDestroy( &line ); |
|
669 AssertMockLtsyStatusL(); |
|
670 |
|
671 // cleanup |
|
672 CleanupStack::PopAndDestroy( &data ); |
|
673 CleanupStack::PopAndDestroy( &completeData ); |
|
674 CleanupStack::PopAndDestroy( &expectData ); |
|
675 CleanupStack::PopAndDestroy( this ); |
|
676 } |
|
677 |
|
678 /** |
|
679 @SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0004 |
|
680 @SYMComponent telephony_ctsy |
|
681 @SYMTestCaseDesc Test support in CTSY for multiple client requests to MTelephonyAudioControl::SetUpCallRouting |
|
682 @SYMTestPriority High |
|
683 @SYMTestActions Invokes multiple client requests to MTelephonyAudioControl::SetUpCallRouting |
|
684 @SYMTestExpectedResults Pass |
|
685 @SYMTestType CT |
|
686 */ |
|
687 void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0004L() |
|
688 { |
|
689 DefinePropeties( EFalse, EVersion2 ); |
|
690 |
|
691 OpenEtelServerL(EUseExtendedError); |
|
692 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
693 OpenPhoneL(); |
|
694 |
|
695 RBuf8 expectData; |
|
696 CleanupClosePushL(expectData); |
|
697 |
|
698 RBuf8 completeData; |
|
699 CleanupClosePushL(completeData); |
|
700 |
|
701 //------------------------------------------------------------------------- |
|
702 // Test A: Test multiple clients requesting MTelephonyAudioControl::SetUpCallRouting |
|
703 //------------------------------------------------------------------------- |
|
704 |
|
705 TInt callId1( 1 ); |
|
706 RCall::TCallParams callParamsX1; |
|
707 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
708 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
709 RMobileCall::TMobileCallParamsV7 callParams; |
|
710 RMobileCall::TMobileCallInfoV8 callInfo; |
|
711 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
712 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
713 callParams.iInterval = 100; |
|
714 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
715 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
716 callParams.iCug.iExplicitInvoke = EFalse; |
|
717 callParams.iCug.iCugIndex = 0xFFFF; |
|
718 callParams.iCug.iSuppressPrefCug = EFalse; |
|
719 callParams.iCug.iSuppressOA = EFalse; |
|
720 callParams.iAutoRedial = EFalse; |
|
721 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
722 callInfo.iService = mobileService; |
|
723 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
724 callInfo.iCallId =-1; |
|
725 callInfo.iExitCode =0; |
|
726 callInfo.iEmergency =0; |
|
727 callInfo.iForwarded =0; |
|
728 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
729 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
730 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
731 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
732 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
733 |
|
734 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
735 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
736 TMockLtsyCallData0 mockData0(callId1, mobileService); |
|
737 |
|
738 // reset line & call |
|
739 RLine line; |
|
740 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
741 CleanupClosePushL( line ); |
|
742 ASSERT_EQUALS( KErrNone, error ); |
|
743 |
|
744 RMobileCall call; |
|
745 error = call.OpenNewCall( line ); |
|
746 CleanupClosePushL( call ); |
|
747 ASSERT_EQUALS( KErrNone, error ); |
|
748 |
|
749 // prepare MockLTSY |
|
750 CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber); |
|
751 mockData2.SerialiseL(expectData); |
|
752 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
753 mockData0.SerialiseL(completeData); |
|
754 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
755 |
|
756 // make the call |
|
757 TRequestStatus status( KErrNone ); |
|
758 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
759 User::WaitForRequest( status ); |
|
760 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
761 |
|
762 error = call.GetMobileCallInfo( callInfoPckg ); |
|
763 ASSERT_EQUALS( KErrNone, error ); |
|
764 |
|
765 // change call status and check it is OK |
|
766 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
767 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
768 |
|
769 // change call status and check it is OK |
|
770 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
771 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
772 |
|
773 // change call status and check it is OK |
|
774 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
775 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
776 |
|
777 // Open second client |
|
778 RTelServer telServer2; |
|
779 error = telServer2.Connect(); |
|
780 ASSERT_EQUALS( KErrNone, error ); |
|
781 CleanupClosePushL( telServer2 ); |
|
782 |
|
783 RMobilePhone phone2; |
|
784 error = phone2.Open( iTelServer,KMmTsyPhoneName ); |
|
785 ASSERT_EQUALS( KErrNone, error ); |
|
786 CleanupClosePushL( phone2 ); |
|
787 |
|
788 RLine line2; |
|
789 error = line2.Open( phone2, KMmTsyVoice1LineName ); |
|
790 CleanupClosePushL( line2 ); |
|
791 ASSERT_EQUALS( KErrNone, error ); |
|
792 |
|
793 RMobileCall call2; |
|
794 error = call2.OpenNewCall( line2 ); |
|
795 CleanupClosePushL( call2 ); |
|
796 ASSERT_EQUALS( KErrNone, error ); |
|
797 |
|
798 TInt callId2( 2 ); |
|
799 // prepare MockLTSY |
|
800 RMobileCall::TMobileCallInfoV8 callInfo2; |
|
801 callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
802 callInfo2.iService = mobileService; |
|
803 callInfo2.iStatus = RMobileCall::EStatusUnknown; |
|
804 callInfo2.iCallId =-1; |
|
805 callInfo2.iExitCode =0; |
|
806 callInfo2.iEmergency =0; |
|
807 callInfo2.iForwarded =0; |
|
808 callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
809 callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
810 callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
811 callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
812 callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
813 TMockLtsyCallData0 mockData01(callId2, mobileService); |
|
814 CallGetMobileCallInfoL(callId2, mobileService, KPhoneNumber); |
|
815 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService, callParams, callInfo2); |
|
816 mockData3.SerialiseL(expectData); |
|
817 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
818 mockData01.SerialiseL(completeData); |
|
819 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
820 |
|
821 // make the call |
|
822 call2.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
823 User::WaitForRequest( status ); |
|
824 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
825 |
|
826 error = call2.GetMobileCallInfo( callInfoPckg ); |
|
827 ASSERT_EQUALS( KErrNone, error ); |
|
828 |
|
829 // change call status and check it is OK |
|
830 UpdateCallStatusL( call2, RMobileCall::EStatusDialling ); |
|
831 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
832 |
|
833 // change call status and check it is OK |
|
834 UpdateCallStatusL( call2, RMobileCall::EStatusConnecting ); |
|
835 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
836 |
|
837 // change call status and check it is OK |
|
838 UpdateCallStatusL( call2, RMobileCall::EStatusConnected ); |
|
839 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
840 |
|
841 TInt callCount(0); |
|
842 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
843 ASSERT_EQUALS( KErrNone, error ); |
|
844 |
|
845 // there should be 2 calls now |
|
846 ASSERT_EQUALS( 2, callCount ); |
|
847 |
|
848 // cleanup |
|
849 |
|
850 // prepare MockLTSY for hangup |
|
851 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
852 TBool autoStChangeDisable ( EFalse ); |
|
853 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId2, mobileService, hangUpCause, autoStChangeDisable ); |
|
854 expectData.Close(); |
|
855 mockHangUpData.SerialiseL(expectData); |
|
856 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
857 |
|
858 CleanupStack::PopAndDestroy( &call2 ); |
|
859 CleanupStack::PopAndDestroy( &line2 ); |
|
860 CleanupStack::PopAndDestroy( &phone2 ); |
|
861 CleanupStack::PopAndDestroy( &telServer2 ); |
|
862 |
|
863 // prepare MockLTSY for hangup |
|
864 TMockLtsyCallData2<TInt, TBool> mockHangUpData2( callId1, mobileService, hangUpCause, autoStChangeDisable ); |
|
865 expectData.Close(); |
|
866 mockHangUpData2.SerialiseL(expectData); |
|
867 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
868 CleanupStack::PopAndDestroy( &call ); |
|
869 CleanupStack::PopAndDestroy( &line ); |
|
870 CleanupStack::PopAndDestroy( &completeData ); |
|
871 CleanupStack::PopAndDestroy( &expectData ); |
|
872 CleanupStack::PopAndDestroy( this ); |
|
873 } |
|
874 |
|
875 /** |
|
876 @SYMTestCaseID BA-CTSY-CRC-CRCTCR-0001a |
|
877 @SYMComponent telephony_ctsy |
|
878 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::TeardownCallRouting |
|
879 @SYMTestPriority High |
|
880 @SYMTestActions Invokes MTelephonyAudioControl::TeardownCallRouting |
|
881 @SYMTestExpectedResults Pass |
|
882 @SYMTestType CT |
|
883 */ |
|
884 void CCTsyTelephonyAudioControlFU::TestTeardownTelephonyAudio0001aL() |
|
885 { |
|
886 DefinePropeties( ETrue, EVersion2 ); |
|
887 OpenEtelServerL(EUseExtendedError); |
|
888 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
889 OpenPhoneL(); |
|
890 |
|
891 RBuf8 expectData; |
|
892 CleanupClosePushL(expectData); |
|
893 |
|
894 RBuf8 completeData; |
|
895 CleanupClosePushL(completeData); |
|
896 |
|
897 TRequestStatus status( KErrNone ); |
|
898 TInt callId( 1 ); |
|
899 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
900 RMobileCall::TMobileCallParamsV7 callParams; |
|
901 RMobileCall::TMobileCallInfoV8 callInfo; |
|
902 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
903 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
904 callParams.iInterval = 100; |
|
905 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
906 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
907 callParams.iCug.iExplicitInvoke = EFalse; |
|
908 callParams.iCug.iCugIndex = 0xFFFF; |
|
909 callParams.iCug.iSuppressPrefCug = EFalse; |
|
910 callParams.iCug.iSuppressOA = EFalse; |
|
911 callParams.iAutoRedial = EFalse; |
|
912 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
913 callInfo.iService = mobileService; |
|
914 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
915 callInfo.iCallId =-1; |
|
916 callInfo.iExitCode =0; |
|
917 callInfo.iEmergency =0; |
|
918 callInfo.iForwarded =0; |
|
919 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
920 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
921 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
922 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
923 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
924 |
|
925 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
926 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
927 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
928 |
|
929 RCall::TCallParams callParamsX1; |
|
930 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
931 |
|
932 TRequestStatus mockLtsyStatus( KErrNone ); |
|
933 RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting ); |
|
934 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus ); |
|
935 |
|
936 RLine line; |
|
937 RMobileCall call; |
|
938 |
|
939 TInt error( KErrNone ); |
|
940 |
|
941 //------------------------------------------------------------------------- |
|
942 // TEST C: Successful completion request of |
|
943 // MTelephonyAudioControl::TeardownCallRouting when result is not cached. |
|
944 //------------------------------------------------------------------------- |
|
945 |
|
946 // MO Call Audio Teardown |
|
947 |
|
948 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting |
|
949 |
|
950 // reset line & call |
|
951 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
952 CleanupClosePushL( line ); |
|
953 ASSERT_EQUALS( KErrNone, error ); |
|
954 |
|
955 error = call.OpenNewCall( line ); |
|
956 CleanupClosePushL( call ); |
|
957 ASSERT_EQUALS( KErrNone, error ); |
|
958 |
|
959 // prepare MockLTSY |
|
960 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
961 mockData2.SerialiseL(expectData); |
|
962 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
963 mockData0.SerialiseL(completeData); |
|
964 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
965 |
|
966 // dial the call |
|
967 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
968 User::WaitForRequest( status ); |
|
969 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
970 |
|
971 error = call.GetMobileCallInfo( callInfoPckg ); |
|
972 ASSERT_EQUALS( KErrNone, error ); |
|
973 |
|
974 // check that call status it is OK |
|
975 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
976 |
|
977 // change call status and check it is OK |
|
978 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
979 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
980 |
|
981 // change call status and check it is OK |
|
982 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
983 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
984 |
|
985 // change call status and check it is OK |
|
986 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
987 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
988 |
|
989 // prepare MockLTSY for hangup |
|
990 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
991 TBool autoStChangeDisable ( ETrue ); |
|
992 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
993 expectData.Close(); |
|
994 mockHangUpData.SerialiseL(expectData); |
|
995 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
996 |
|
997 completeData.Close(); |
|
998 TMockLtsyCallData0 mockData3(callId, mobileService); |
|
999 mockData3.SerialiseL(completeData); |
|
1000 iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); |
|
1001 // hangup the call |
|
1002 call.HangUp( status ); |
|
1003 User::WaitForRequest( status ); |
|
1004 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1005 |
|
1006 // change call status and check it is OK |
|
1007 UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting ); |
|
1008 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnecting ); |
|
1009 |
|
1010 // change call status and check it is OK |
|
1011 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
1012 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1013 |
|
1014 |
|
1015 TInt callCount(0); |
|
1016 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1017 ASSERT_EQUALS( KErrNone, error ); |
|
1018 |
|
1019 // there should not be any calls |
|
1020 ASSERT_EQUALS( 0, callCount ); |
|
1021 |
|
1022 // cleanup |
|
1023 AssertMockLtsyStatusL(); |
|
1024 CleanupStack::PopAndDestroy( &call ); |
|
1025 AssertMockLtsyStatusL(); |
|
1026 CleanupStack::PopAndDestroy( &line ); |
|
1027 AssertMockLtsyStatusL(); |
|
1028 |
|
1029 DoCleanup(); |
|
1030 |
|
1031 // MT Call Audio Teardown |
|
1032 |
|
1033 // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband |
|
1034 |
|
1035 DefinePropeties( ETrue, EVersion2 ); |
|
1036 OpenEtelServerL(EUseExtendedError); |
|
1037 OpenPhoneL(); |
|
1038 |
|
1039 // reset line |
|
1040 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1041 CleanupClosePushL( line ); |
|
1042 ASSERT_EQUALS( KErrNone, error ); |
|
1043 |
|
1044 // notify incoming call |
|
1045 TName incomingCallName; |
|
1046 line.NotifyIncomingCall( status, incomingCallName ); |
|
1047 |
|
1048 // create incoming call notification |
|
1049 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo ); |
|
1050 mockCallData.SerialiseL( completeData ); |
|
1051 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
1052 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
1053 User::WaitForRequest( mockLtsyStatus ); |
|
1054 AssertMockLtsyStatusL(); |
|
1055 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
1056 |
|
1057 // wait for notification |
|
1058 User::WaitForRequest( status ); |
|
1059 AssertMockLtsyStatusL(); |
|
1060 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1061 |
|
1062 // create call ringing notification |
|
1063 completeData.Close(); |
|
1064 mobileCallStatus = RMobileCall::EStatusRinging; |
|
1065 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus ); |
|
1066 mockCallData2.SerialiseL(completeData); |
|
1067 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
1068 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
1069 User::WaitForRequest(mockLtsyStatus); |
|
1070 AssertMockLtsyStatusL(); |
|
1071 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
1072 |
|
1073 // prepare MockLTSY for answer |
|
1074 expectData.Close(); |
|
1075 mockData0.SerialiseL( expectData ); |
|
1076 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
1077 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
1078 |
|
1079 // reset the call |
|
1080 error = call.OpenExistingCall( line, incomingCallName ); |
|
1081 CleanupClosePushL( call ); |
|
1082 ASSERT_EQUALS( KErrNone, error ); |
|
1083 |
|
1084 // answer the call |
|
1085 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
1086 User::WaitForRequest( status ); |
|
1087 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1088 |
|
1089 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1090 ASSERT_EQUALS( KErrNone, error ); |
|
1091 |
|
1092 // change call status and check it is OK |
|
1093 UpdateCallStatusL( call, RMobileCall::EStatusAnswering ); |
|
1094 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering ); |
|
1095 |
|
1096 // change call status and check it is OK |
|
1097 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
1098 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
1099 |
|
1100 // change call status and check it is OK |
|
1101 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
1102 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
1103 |
|
1104 // change call status and check it is OK |
|
1105 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband, ETrue ); |
|
1106 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
1107 |
|
1108 // change call status and check it is OK |
|
1109 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
1110 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1111 |
|
1112 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1113 ASSERT_EQUALS( KErrNone, error ); |
|
1114 |
|
1115 // there should not be any calls |
|
1116 ASSERT_EQUALS( 0, callCount ); |
|
1117 |
|
1118 // cleanup |
|
1119 AssertMockLtsyStatusL(); |
|
1120 CleanupStack::PopAndDestroy( &call ); |
|
1121 AssertMockLtsyStatusL(); |
|
1122 CleanupStack::PopAndDestroy( &line ); |
|
1123 AssertMockLtsyStatusL(); |
|
1124 |
|
1125 DoCleanup(); |
|
1126 |
|
1127 // MT Call Audio Setup - Immediate Failure Case |
|
1128 |
|
1129 DefinePropeties( ETrue, EVersion2 ); |
|
1130 OpenEtelServerL(EUseExtendedError); |
|
1131 OpenPhoneL(); |
|
1132 |
|
1133 // reset line |
|
1134 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1135 CleanupClosePushL( line ); |
|
1136 ASSERT_EQUALS( KErrNone, error ); |
|
1137 |
|
1138 // notify incoming call |
|
1139 line.NotifyIncomingCall( status, incomingCallName ); |
|
1140 |
|
1141 // create incoming call notification |
|
1142 mockCallData.SerialiseL( completeData ); |
|
1143 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
1144 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
1145 User::WaitForRequest( mockLtsyStatus ); |
|
1146 AssertMockLtsyStatusL(); |
|
1147 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
1148 |
|
1149 // wait for notification |
|
1150 User::WaitForRequest( status ); |
|
1151 AssertMockLtsyStatusL(); |
|
1152 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1153 |
|
1154 // create call ringing notification |
|
1155 completeData.Close(); |
|
1156 mockCallData2.SerialiseL(completeData); |
|
1157 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
1158 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
1159 User::WaitForRequest(mockLtsyStatus); |
|
1160 AssertMockLtsyStatusL(); |
|
1161 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
1162 |
|
1163 // prepare MockLTSY for answer |
|
1164 expectData.Close(); |
|
1165 mockData0.SerialiseL( expectData ); |
|
1166 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
1167 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
1168 |
|
1169 // reset the call |
|
1170 error = call.OpenExistingCall( line, incomingCallName ); |
|
1171 CleanupClosePushL( call ); |
|
1172 ASSERT_EQUALS( KErrNone, error ); |
|
1173 |
|
1174 // answer the call |
|
1175 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
1176 User::WaitForRequest( status ); |
|
1177 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1178 |
|
1179 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1180 ASSERT_EQUALS( KErrNone, error ); |
|
1181 |
|
1182 // create error by changing call state back to idle |
|
1183 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
1184 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1185 |
|
1186 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1187 ASSERT_EQUALS( KErrNone, error ); |
|
1188 |
|
1189 // there should not be any calls |
|
1190 ASSERT_EQUALS( 0, callCount ); |
|
1191 |
|
1192 // cleanup |
|
1193 AssertMockLtsyStatusL(); |
|
1194 CleanupStack::PopAndDestroy( &call ); |
|
1195 AssertMockLtsyStatusL(); |
|
1196 CleanupStack::PopAndDestroy( &line ); |
|
1197 AssertMockLtsyStatusL(); |
|
1198 |
|
1199 DoCleanup(); |
|
1200 |
|
1201 // MT Call Audio Setup - In Progress Failure Case |
|
1202 |
|
1203 // EStatusAnswering -> EStatusIdle |
|
1204 |
|
1205 DefinePropeties( ETrue, EVersion2 ); |
|
1206 OpenEtelServerL(EUseExtendedError); |
|
1207 OpenPhoneL(); |
|
1208 |
|
1209 // reset line |
|
1210 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1211 CleanupClosePushL( line ); |
|
1212 ASSERT_EQUALS( KErrNone, error ); |
|
1213 |
|
1214 // notify incoming call |
|
1215 line.NotifyIncomingCall( status, incomingCallName ); |
|
1216 |
|
1217 // create incoming call notification |
|
1218 mockCallData.SerialiseL( completeData ); |
|
1219 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
1220 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
1221 User::WaitForRequest( mockLtsyStatus ); |
|
1222 AssertMockLtsyStatusL(); |
|
1223 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
1224 |
|
1225 // wait for notification |
|
1226 User::WaitForRequest( status ); |
|
1227 AssertMockLtsyStatusL(); |
|
1228 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1229 |
|
1230 // create call ringing notification |
|
1231 completeData.Close(); |
|
1232 mobileCallStatus = RMobileCall::EStatusRinging; |
|
1233 mockCallData2.SerialiseL(completeData); |
|
1234 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
1235 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
1236 User::WaitForRequest(mockLtsyStatus); |
|
1237 AssertMockLtsyStatusL(); |
|
1238 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
1239 |
|
1240 // prepare MockLTSY for answer |
|
1241 expectData.Close(); |
|
1242 mockData0.SerialiseL( expectData ); |
|
1243 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
1244 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
1245 |
|
1246 // reset the call |
|
1247 error = call.OpenExistingCall( line, incomingCallName ); |
|
1248 CleanupClosePushL( call ); |
|
1249 ASSERT_EQUALS( KErrNone, error ); |
|
1250 |
|
1251 // answer the call |
|
1252 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
1253 User::WaitForRequest( status ); |
|
1254 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1255 |
|
1256 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1257 ASSERT_EQUALS( KErrNone, error ); |
|
1258 |
|
1259 // change call state and check it is OK |
|
1260 UpdateCallStatusL( call, RMobileCall::EStatusAnswering ); |
|
1261 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering ); |
|
1262 |
|
1263 // create error by changing call state back to idle |
|
1264 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
1265 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1266 |
|
1267 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1268 ASSERT_EQUALS( KErrNone, error ); |
|
1269 |
|
1270 // there should not be any calls |
|
1271 ASSERT_EQUALS( 0, callCount ); |
|
1272 |
|
1273 // cleanup |
|
1274 AssertMockLtsyStatusL(); |
|
1275 CleanupStack::PopAndDestroy( &call ); |
|
1276 AssertMockLtsyStatusL(); |
|
1277 CleanupStack::PopAndDestroy( &line ); |
|
1278 AssertMockLtsyStatusL(); |
|
1279 |
|
1280 DoCleanup(); |
|
1281 |
|
1282 // MT Call Audio Setup - Immediate Failure Case |
|
1283 |
|
1284 DefinePropeties( ETrue, EVersion2 ); |
|
1285 OpenEtelServerL(EUseExtendedError); |
|
1286 OpenPhoneL(); |
|
1287 |
|
1288 // reset line & call |
|
1289 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1290 CleanupClosePushL( line ); |
|
1291 ASSERT_EQUALS( KErrNone, error ); |
|
1292 |
|
1293 error = call.OpenNewCall( line ); |
|
1294 CleanupClosePushL( call ); |
|
1295 ASSERT_EQUALS( KErrNone, error ); |
|
1296 |
|
1297 // prepare MockLTSY |
|
1298 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
1299 RMobileCall::TMobileCallInfoV8 callInfo2; |
|
1300 callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
1301 callInfo2.iService = mobileService; |
|
1302 callInfo2.iStatus = RMobileCall::EStatusUnknown; |
|
1303 callInfo2.iCallId =-1; |
|
1304 callInfo2.iExitCode =0; |
|
1305 callInfo2.iEmergency =0; |
|
1306 callInfo2.iForwarded =0; |
|
1307 callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
1308 callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
1309 callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
1310 callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
1311 callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
1312 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData4(0, mobileService, callParams, callInfo2); |
|
1313 mockData4.SerialiseL(expectData); |
|
1314 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
1315 mockData0.SerialiseL(completeData); |
|
1316 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
1317 |
|
1318 // dial the call |
|
1319 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
1320 User::WaitForRequest( status ); |
|
1321 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1322 |
|
1323 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1324 ASSERT_EQUALS( KErrNone, error ); |
|
1325 |
|
1326 // check that call status it is OK |
|
1327 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
1328 |
|
1329 // change call status and check it is OK |
|
1330 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
1331 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1332 |
|
1333 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1334 ASSERT_EQUALS( KErrNone, error ); |
|
1335 |
|
1336 // there should not be any calls |
|
1337 ASSERT_EQUALS( 0, callCount ); |
|
1338 |
|
1339 // cleanup |
|
1340 AssertMockLtsyStatusL(); |
|
1341 CleanupStack::PopAndDestroy( &call ); |
|
1342 AssertMockLtsyStatusL(); |
|
1343 CleanupStack::PopAndDestroy( &line ); |
|
1344 AssertMockLtsyStatusL(); |
|
1345 |
|
1346 DoCleanup(); |
|
1347 |
|
1348 // MO Call Audio Setup - In Progress Failure Case |
|
1349 |
|
1350 DefinePropeties( ETrue, EVersion2 ); |
|
1351 OpenEtelServerL(EUseExtendedError); |
|
1352 OpenPhoneL(); |
|
1353 |
|
1354 // reset line & call |
|
1355 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1356 CleanupClosePushL( line ); |
|
1357 ASSERT_EQUALS( KErrNone, error ); |
|
1358 |
|
1359 error = call.OpenNewCall( line ); |
|
1360 CleanupClosePushL( call ); |
|
1361 ASSERT_EQUALS( KErrNone, error ); |
|
1362 |
|
1363 // prepare MockLTSY |
|
1364 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
1365 mockData4.SerialiseL(expectData); |
|
1366 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
1367 mockData0.SerialiseL(completeData); |
|
1368 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
1369 |
|
1370 // dial the call |
|
1371 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
1372 User::WaitForRequest( status ); |
|
1373 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1374 |
|
1375 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1376 ASSERT_EQUALS( KErrNone, error ); |
|
1377 |
|
1378 // check that call status it is OK |
|
1379 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
1380 |
|
1381 // change call status and check it is OK |
|
1382 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
1383 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
1384 |
|
1385 // create error by setting the call back to the idle |
|
1386 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
1387 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1388 |
|
1389 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1390 ASSERT_EQUALS( KErrNone, error ); |
|
1391 |
|
1392 // there should not be any calls |
|
1393 ASSERT_EQUALS( 0, callCount ); |
|
1394 |
|
1395 // cleanup |
|
1396 AssertMockLtsyStatusL(); |
|
1397 CleanupStack::PopAndDestroy( &call ); |
|
1398 AssertMockLtsyStatusL(); |
|
1399 CleanupStack::PopAndDestroy( &line ); |
|
1400 AssertMockLtsyStatusL(); |
|
1401 |
|
1402 // cleanup |
|
1403 AssertMockLtsyStatusL(); |
|
1404 |
|
1405 DeletePropeties(); |
|
1406 CleanupStack::PopAndDestroy( &completeData ); |
|
1407 CleanupStack::PopAndDestroy( &expectData ); |
|
1408 CleanupStack::PopAndDestroy( this ); |
|
1409 } |
|
1410 |
|
1411 /** |
|
1412 @SYMTestCaseID BA-CTSY-CRC-CRCTCR-0001b |
|
1413 @SYMComponent telephony_ctsy |
|
1414 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::TeardownCallRouting by using LTSY version1 |
|
1415 @SYMTestPriority High |
|
1416 @SYMTestActions Invokes MTelephonyAudioControl::TeardownCallRouting |
|
1417 @SYMTestExpectedResults Pass |
|
1418 @SYMTestType CT |
|
1419 */ |
|
1420 void CCTsyTelephonyAudioControlFU::TestTeardownTelephonyAudio0001bL() |
|
1421 { |
|
1422 DefinePropeties( ETrue, EVersion1 ); |
|
1423 OpenEtelServerL(EUseExtendedError); |
|
1424 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
1425 OpenPhoneL(); |
|
1426 |
|
1427 RBuf8 expectData; |
|
1428 CleanupClosePushL(expectData); |
|
1429 |
|
1430 RBuf8 completeData; |
|
1431 CleanupClosePushL(completeData); |
|
1432 |
|
1433 TRequestStatus status( KErrNone ); |
|
1434 TInt callId( 1 ); |
|
1435 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
1436 RMobileCall::TMobileCallParamsV7 callParams; |
|
1437 RMobileCall::TMobileCallInfoV8 callInfo; |
|
1438 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
1439 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
1440 callParams.iInterval = 100; |
|
1441 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
1442 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
1443 callParams.iCug.iExplicitInvoke = EFalse; |
|
1444 callParams.iCug.iCugIndex = 0xFFFF; |
|
1445 callParams.iCug.iSuppressPrefCug = EFalse; |
|
1446 callParams.iCug.iSuppressOA = EFalse; |
|
1447 callParams.iAutoRedial = EFalse; |
|
1448 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
1449 callInfo.iService = mobileService; |
|
1450 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
1451 callInfo.iCallId =-1; |
|
1452 callInfo.iExitCode =0; |
|
1453 callInfo.iEmergency =0; |
|
1454 callInfo.iForwarded =0; |
|
1455 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
1456 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
1457 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
1458 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
1459 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
1460 |
|
1461 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
1462 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
1463 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
1464 |
|
1465 RCall::TCallParams callParamsX1; |
|
1466 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
1467 |
|
1468 TRequestStatus mockLtsyStatus( KErrNone ); |
|
1469 RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting ); |
|
1470 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus ); |
|
1471 |
|
1472 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
1473 TBool autoStChangeDisable ( ETrue ); |
|
1474 |
|
1475 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
1476 |
|
1477 RLine line; |
|
1478 RMobileCall call; |
|
1479 |
|
1480 TInt error( KErrNone ); |
|
1481 |
|
1482 //------------------------------------------------------------------------- |
|
1483 // TEST C: Successful completion request of |
|
1484 // MTelephonyAudioControl::TeardownCallRouting when result is not cached. |
|
1485 //------------------------------------------------------------------------- |
|
1486 |
|
1487 // MO Call Audio Teardown |
|
1488 |
|
1489 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting |
|
1490 |
|
1491 // reset line & call |
|
1492 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1493 CleanupClosePushL( line ); |
|
1494 ASSERT_EQUALS( KErrNone, error ); |
|
1495 |
|
1496 error = call.OpenNewCall( line ); |
|
1497 CleanupClosePushL( call ); |
|
1498 ASSERT_EQUALS( KErrNone, error ); |
|
1499 |
|
1500 // prepare MockLTSY |
|
1501 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
1502 mockData2.SerialiseL(expectData); |
|
1503 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
1504 mockData0.SerialiseL(completeData); |
|
1505 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
1506 |
|
1507 // dial the call |
|
1508 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
1509 User::WaitForRequest( status ); |
|
1510 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1511 |
|
1512 // check that there is no call routing done |
|
1513 CheckNoCallRouting(); |
|
1514 |
|
1515 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1516 ASSERT_EQUALS( KErrNone, error ); |
|
1517 |
|
1518 // change call status |
|
1519 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
1520 |
|
1521 // check that there is no call routing done |
|
1522 CheckNoCallRouting(); |
|
1523 |
|
1524 // change call status |
|
1525 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
1526 |
|
1527 // check that there is no call routing done |
|
1528 CheckNoCallRouting(); |
|
1529 |
|
1530 // change call status |
|
1531 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
1532 |
|
1533 // check that there is no call routing done |
|
1534 CheckNoCallRouting(); |
|
1535 |
|
1536 // prepare MockLTSY for hangup |
|
1537 expectData.Close(); |
|
1538 mockHangUpData.SerialiseL(expectData); |
|
1539 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
1540 |
|
1541 completeData.Close(); |
|
1542 TMockLtsyCallData0 mockData3(callId, mobileService); |
|
1543 mockData3.SerialiseL(completeData); |
|
1544 iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); |
|
1545 // hangup the call |
|
1546 call.HangUp( status ); |
|
1547 User::WaitForRequest( status ); |
|
1548 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1549 |
|
1550 // check that there is no call routing done |
|
1551 CheckNoCallRouting(); |
|
1552 |
|
1553 // change call status |
|
1554 UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting ); |
|
1555 |
|
1556 // check that there is no call routing done |
|
1557 CheckNoCallRouting(); |
|
1558 |
|
1559 // change call status and check it is OK |
|
1560 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
1561 |
|
1562 // check that there is no call routing done |
|
1563 CheckNoCallRouting(); |
|
1564 |
|
1565 // cleanup |
|
1566 AssertMockLtsyStatusL(); |
|
1567 CleanupStack::PopAndDestroy( &call ); |
|
1568 AssertMockLtsyStatusL(); |
|
1569 CleanupStack::PopAndDestroy( &line ); |
|
1570 AssertMockLtsyStatusL(); |
|
1571 |
|
1572 DoCleanup(); |
|
1573 |
|
1574 // MT Call Audio Teardown |
|
1575 |
|
1576 // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband |
|
1577 |
|
1578 DefinePropeties( ETrue, EVersion1 ); |
|
1579 OpenEtelServerL(EUseExtendedError); |
|
1580 OpenPhoneL(); |
|
1581 |
|
1582 // reset line |
|
1583 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1584 CleanupClosePushL( line ); |
|
1585 ASSERT_EQUALS( KErrNone, error ); |
|
1586 |
|
1587 // notify incoming call |
|
1588 TName incomingCallName; |
|
1589 line.NotifyIncomingCall( status, incomingCallName ); |
|
1590 |
|
1591 // create incoming call notification |
|
1592 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo ); |
|
1593 mockCallData.SerialiseL( completeData ); |
|
1594 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
1595 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
1596 User::WaitForRequest( mockLtsyStatus ); |
|
1597 AssertMockLtsyStatusL(); |
|
1598 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
1599 |
|
1600 // wait for notification |
|
1601 User::WaitForRequest( status ); |
|
1602 AssertMockLtsyStatusL(); |
|
1603 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1604 |
|
1605 // create call ringing notification |
|
1606 completeData.Close(); |
|
1607 mobileCallStatus = RMobileCall::EStatusRinging; |
|
1608 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus ); |
|
1609 mockCallData2.SerialiseL(completeData); |
|
1610 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
1611 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
1612 User::WaitForRequest(mockLtsyStatus); |
|
1613 AssertMockLtsyStatusL(); |
|
1614 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
1615 |
|
1616 // prepare MockLTSY for answer |
|
1617 expectData.Close(); |
|
1618 mockData0.SerialiseL( expectData ); |
|
1619 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
1620 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
1621 |
|
1622 // reset the call |
|
1623 error = call.OpenExistingCall( line, incomingCallName ); |
|
1624 CleanupClosePushL( call ); |
|
1625 ASSERT_EQUALS( KErrNone, error ); |
|
1626 |
|
1627 // answer the call |
|
1628 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
1629 User::WaitForRequest( status ); |
|
1630 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1631 |
|
1632 // check that there is no call routing done |
|
1633 CheckNoCallRouting(); |
|
1634 |
|
1635 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1636 ASSERT_EQUALS( KErrNone, error ); |
|
1637 |
|
1638 // change call status |
|
1639 UpdateCallStatusL( call, RMobileCall::EStatusAnswering ); |
|
1640 |
|
1641 // check that there is no call routing done |
|
1642 CheckNoCallRouting(); |
|
1643 |
|
1644 // change call status |
|
1645 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
1646 |
|
1647 // check that there is no call routing done |
|
1648 CheckNoCallRouting(); |
|
1649 |
|
1650 // change call status |
|
1651 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
1652 |
|
1653 // check that there is no call routing done |
|
1654 CheckNoCallRouting(); |
|
1655 |
|
1656 // change call status |
|
1657 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
1658 |
|
1659 // check that there is no call routing done |
|
1660 CheckNoCallRouting(); |
|
1661 |
|
1662 // change call status |
|
1663 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
1664 |
|
1665 // check that there is no call routing done |
|
1666 CheckNoCallRouting(); |
|
1667 |
|
1668 // cleanup |
|
1669 AssertMockLtsyStatusL(); |
|
1670 CleanupStack::PopAndDestroy( &call ); |
|
1671 AssertMockLtsyStatusL(); |
|
1672 CleanupStack::PopAndDestroy( &line ); |
|
1673 AssertMockLtsyStatusL(); |
|
1674 |
|
1675 // cleanup |
|
1676 DeletePropeties(); |
|
1677 CleanupStack::PopAndDestroy( &completeData ); |
|
1678 CleanupStack::PopAndDestroy( &expectData ); |
|
1679 CleanupStack::PopAndDestroy( this ); |
|
1680 } |
|
1681 |
|
1682 |
|
1683 /** |
|
1684 @SYMTestCaseID BA-CTSY-CRC-CRCTCR-0004 |
|
1685 @SYMComponent telephony_ctsy |
|
1686 @SYMTestCaseDesc Test support in CTSY for multiple client requests to MTelephonyAudioControl::TeardownCallRouting |
|
1687 @SYMTestPriority High |
|
1688 @SYMTestActions Invokes multiple client requests to MTelephonyAudioControl::TeardownCallRouting |
|
1689 @SYMTestExpectedResults Pass |
|
1690 @SYMTestType CT |
|
1691 */ |
|
1692 void CCTsyTelephonyAudioControlFU::TestTeardownTelephonyAudio0004L() |
|
1693 { |
|
1694 DefinePropeties( EFalse, EVersion2 ); |
|
1695 |
|
1696 OpenEtelServerL(EUseExtendedError); |
|
1697 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
1698 OpenPhoneL(); |
|
1699 |
|
1700 RBuf8 expectData; |
|
1701 CleanupClosePushL(expectData); |
|
1702 |
|
1703 RBuf8 completeData; |
|
1704 CleanupClosePushL(completeData); |
|
1705 |
|
1706 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
1707 TBool autoStChangeDisable ( ETrue ); |
|
1708 |
|
1709 TInt callId1( 1 ); |
|
1710 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
1711 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId1, mobileService, hangUpCause, autoStChangeDisable ); |
|
1712 |
|
1713 RCall::TCallParams callParamsX1; |
|
1714 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
1715 RMobileCall::TMobileCallParamsV7 callParams; |
|
1716 RMobileCall::TMobileCallInfoV8 callInfo; |
|
1717 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
1718 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
1719 callParams.iInterval = 100; |
|
1720 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
1721 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
1722 callParams.iCug.iExplicitInvoke = EFalse; |
|
1723 callParams.iCug.iCugIndex = 0xFFFF; |
|
1724 callParams.iCug.iSuppressPrefCug = EFalse; |
|
1725 callParams.iCug.iSuppressOA = EFalse; |
|
1726 callParams.iAutoRedial = EFalse; |
|
1727 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
1728 callInfo.iService = mobileService; |
|
1729 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
1730 callInfo.iCallId =-1; |
|
1731 callInfo.iExitCode =0; |
|
1732 callInfo.iEmergency =0; |
|
1733 callInfo.iForwarded =0; |
|
1734 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
1735 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
1736 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
1737 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
1738 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
1739 |
|
1740 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
1741 TMockLtsyCallData0 mockData0(callId1, mobileService); |
|
1742 |
|
1743 //------------------------------------------------------------------------- |
|
1744 // Test A: Test multiple clients requesting MTelephonyAudioControl::SetUpCallRouting |
|
1745 //------------------------------------------------------------------------- |
|
1746 |
|
1747 // reset line & call |
|
1748 RLine line; |
|
1749 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
1750 CleanupClosePushL( line ); |
|
1751 ASSERT_EQUALS( KErrNone, error ); |
|
1752 |
|
1753 RMobileCall call; |
|
1754 error = call.OpenNewCall( line ); |
|
1755 CleanupClosePushL( call ); |
|
1756 ASSERT_EQUALS( KErrNone, error ); |
|
1757 |
|
1758 // prepare MockLTSY |
|
1759 CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber); |
|
1760 mockData2.SerialiseL(expectData); |
|
1761 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
1762 mockData0.SerialiseL(completeData); |
|
1763 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
1764 |
|
1765 // make the call |
|
1766 TRequestStatus status( KErrNone ); |
|
1767 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
1768 User::WaitForRequest( status ); |
|
1769 |
|
1770 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1771 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
1772 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1773 |
|
1774 ASSERT_EQUALS( KErrNone, error ); |
|
1775 // change call status and check it is OK |
|
1776 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
1777 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
1778 |
|
1779 // change call status and check it is OK |
|
1780 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
1781 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
1782 |
|
1783 // change call status and check it is OK |
|
1784 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
1785 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
1786 |
|
1787 TInt callCount(0); |
|
1788 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1789 ASSERT_EQUALS( KErrNone, error ); |
|
1790 // there should be 1 call now |
|
1791 ASSERT_EQUALS( 1, callCount ); |
|
1792 |
|
1793 // Open second client |
|
1794 RTelServer telServer2; |
|
1795 error = telServer2.Connect(); |
|
1796 ASSERT_EQUALS( KErrNone, error ); |
|
1797 CleanupClosePushL( telServer2 ); |
|
1798 |
|
1799 RMobilePhone phone2; |
|
1800 error = phone2.Open( telServer2,KMmTsyPhoneName ); |
|
1801 CleanupClosePushL( phone2 ); |
|
1802 ASSERT_EQUALS( KErrNone, error ); |
|
1803 |
|
1804 RLine line2; |
|
1805 error = line2.Open( phone2, KMmTsyVoice1LineName ); |
|
1806 CleanupClosePushL( line2 ); |
|
1807 ASSERT_EQUALS( KErrNone, error ); |
|
1808 |
|
1809 RMobileCall call2; |
|
1810 error = call2.OpenNewCall( line2 ); |
|
1811 CleanupClosePushL( call2 ); |
|
1812 ASSERT_EQUALS( KErrNone, error ); |
|
1813 |
|
1814 TInt callId2( 2 ); |
|
1815 // prepare MockLTSY |
|
1816 TMockLtsyCallData0 mockData01(callId2, mobileService); |
|
1817 CallGetMobileCallInfoL(callId2, mobileService, KPhoneNumber); |
|
1818 RMobileCall::TMobileCallInfoV8 callInfo2; |
|
1819 callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
1820 callInfo2.iService = mobileService; |
|
1821 callInfo2.iStatus = RMobileCall::EStatusUnknown; |
|
1822 callInfo2.iCallId =-1; |
|
1823 callInfo2.iExitCode =0; |
|
1824 callInfo2.iEmergency =0; |
|
1825 callInfo2.iForwarded =0; |
|
1826 callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
1827 callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
1828 callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
1829 callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
1830 callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
1831 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService, callParams, callInfo2); |
|
1832 mockData3.SerialiseL(expectData); |
|
1833 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
1834 mockData01.SerialiseL(completeData); |
|
1835 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
1836 |
|
1837 // make the call |
|
1838 call2.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
1839 User::WaitForRequest( status ); |
|
1840 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
1841 |
|
1842 error = call2.GetMobileCallInfo( callInfoPckg ); |
|
1843 ASSERT_EQUALS( KErrNone, error ); |
|
1844 |
|
1845 // change call status and check it is OK |
|
1846 UpdateCallStatusL( call2, RMobileCall::EStatusDialling ); |
|
1847 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
1848 |
|
1849 // change call status and check it is OK |
|
1850 UpdateCallStatusL( call2, RMobileCall::EStatusConnecting ); |
|
1851 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
1852 |
|
1853 // change call status and check it is OK |
|
1854 UpdateCallStatusL( call2, RMobileCall::EStatusConnected ); |
|
1855 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
1856 |
|
1857 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1858 ASSERT_EQUALS( KErrNone, error ); |
|
1859 |
|
1860 // there should be 2 calls now |
|
1861 ASSERT_EQUALS( 2, callCount ); |
|
1862 |
|
1863 // hangup call 1 |
|
1864 error = call.GetMobileCallInfo( callInfoPckg ); |
|
1865 ASSERT_EQUALS( KErrNone, error ); |
|
1866 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband, ETrue ); |
|
1867 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
1868 |
|
1869 // change call status and check it is OK |
|
1870 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
1871 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1872 |
|
1873 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1874 ASSERT_EQUALS( KErrNone, error ); |
|
1875 |
|
1876 // there should 1 call |
|
1877 ASSERT_EQUALS( 1, callCount ); |
|
1878 |
|
1879 // hangup call 2 |
|
1880 error = call2.GetMobileCallInfo( callInfoPckg ); |
|
1881 ASSERT_EQUALS( KErrNone, error ); |
|
1882 UpdateCallStatusL( call2, RMobileCall::EStatusDisconnectingWithInband, ETrue ); |
|
1883 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
1884 |
|
1885 // change call status and check it is OK |
|
1886 UpdateCallStatusL( call2, RMobileCall::EStatusIdle, ETrue ); |
|
1887 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
1888 |
|
1889 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1890 ASSERT_EQUALS( KErrNone, error ); |
|
1891 |
|
1892 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
1893 ASSERT_EQUALS( KErrNone, error ); |
|
1894 |
|
1895 // there should not be any calls |
|
1896 ASSERT_EQUALS( 0, callCount ); |
|
1897 |
|
1898 // cleanup |
|
1899 CleanupStack::PopAndDestroy( &call2 ); |
|
1900 CleanupStack::PopAndDestroy( &line2 ); |
|
1901 CleanupStack::PopAndDestroy( &phone2 ); |
|
1902 CleanupStack::PopAndDestroy( &telServer2 ); |
|
1903 CleanupStack::PopAndDestroy( &call ); |
|
1904 CleanupStack::PopAndDestroy( &line ); |
|
1905 CleanupStack::PopAndDestroy( &completeData ); |
|
1906 CleanupStack::PopAndDestroy( &expectData ); |
|
1907 CleanupStack::PopAndDestroy( this ); |
|
1908 } |
|
1909 |
|
1910 /** |
|
1911 @SYMTestCaseID BA-CTSY-CRC-CRCCRST-0001a |
|
1912 @SYMComponent telephony_ctsy |
|
1913 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::CallStateChange |
|
1914 @SYMTestPriority High |
|
1915 @SYMTestActions Invokes MTelephonyAudioControl::CallStateChange |
|
1916 @SYMTestExpectedResults Pass |
|
1917 @SYMTestType CT |
|
1918 */ |
|
1919 void CCTsyTelephonyAudioControlFU::TestCallStateChange0001aL() |
|
1920 |
|
1921 { |
|
1922 |
|
1923 /* CallStateChange function is called when call has changed its state to the following states: |
|
1924 EStatusDialling |
|
1925 EStatusAnswering |
|
1926 EStatusConnecting |
|
1927 EStatusHold |
|
1928 EStatusDisconnecting |
|
1929 EStatusDisconnectingWithInband |
|
1930 EStatusConnected |
|
1931 */ |
|
1932 DefinePropeties( ETrue, EVersion2 ); |
|
1933 |
|
1934 OpenEtelServerL(EUseExtendedError); |
|
1935 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
1936 OpenPhoneL(); |
|
1937 |
|
1938 RBuf8 data; |
|
1939 CleanupClosePushL(data); |
|
1940 |
|
1941 RBuf8 expectData; |
|
1942 CleanupClosePushL(expectData); |
|
1943 |
|
1944 RBuf8 completeData; |
|
1945 CleanupClosePushL(completeData); |
|
1946 |
|
1947 TRequestStatus status( KErrNone ); |
|
1948 TInt callId( 1 ); |
|
1949 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
1950 RMobileCall::TMobileCallParamsV7 callParams; |
|
1951 RMobileCall::TMobileCallInfoV8 callInfo; |
|
1952 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
1953 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
1954 callParams.iInterval = 100; |
|
1955 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
1956 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
1957 callParams.iCug.iExplicitInvoke = EFalse; |
|
1958 callParams.iCug.iCugIndex = 0xFFFF; |
|
1959 callParams.iCug.iSuppressPrefCug = EFalse; |
|
1960 callParams.iCug.iSuppressOA = EFalse; |
|
1961 callParams.iAutoRedial = EFalse; |
|
1962 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
1963 callInfo.iService = mobileService; |
|
1964 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
1965 callInfo.iCallId =-1; |
|
1966 callInfo.iExitCode =0; |
|
1967 callInfo.iEmergency =0; |
|
1968 callInfo.iForwarded =0; |
|
1969 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
1970 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
1971 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
1972 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
1973 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
1974 |
|
1975 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
1976 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
1977 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
1978 |
|
1979 RCall::TCallParams callParamsX1; |
|
1980 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
1981 |
|
1982 TRequestStatus mockLtsyStatus( KErrNone ); |
|
1983 RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting ); |
|
1984 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus ); |
|
1985 |
|
1986 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
1987 TBool autoStChangeDisable ( ETrue ); |
|
1988 |
|
1989 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
1990 |
|
1991 RLine line; |
|
1992 RMobileCall call; |
|
1993 |
|
1994 //------------------------------------------------------------------------- |
|
1995 // TEST C: Successful completion request of |
|
1996 // MTelephonyAudioControl::CallStateChange when result is not cached. |
|
1997 //------------------------------------------------------------------------- |
|
1998 |
|
1999 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting |
|
2000 |
|
2001 // reset line & call |
|
2002 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2003 CleanupClosePushL( line ); |
|
2004 ASSERT_EQUALS( KErrNone, error ); |
|
2005 |
|
2006 error = call.OpenNewCall( line ); |
|
2007 CleanupClosePushL( call ); |
|
2008 ASSERT_EQUALS( KErrNone, error ); |
|
2009 |
|
2010 // prepare MockLTSY |
|
2011 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
2012 mockData2.SerialiseL(expectData); |
|
2013 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
2014 mockData0.SerialiseL(completeData); |
|
2015 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
2016 |
|
2017 // dial the call |
|
2018 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
2019 User::WaitForRequest( status ); |
|
2020 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2021 |
|
2022 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2023 ASSERT_EQUALS( KErrNone, error ); |
|
2024 |
|
2025 // check that call status it is OK |
|
2026 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
2027 |
|
2028 // change call status and check it is OK |
|
2029 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
2030 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
2031 |
|
2032 // change call status and check it is OK |
|
2033 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2034 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
2035 |
|
2036 // change call status and check it is OK |
|
2037 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2038 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
2039 |
|
2040 // prepare MockLTSY for hangup |
|
2041 expectData.Close(); |
|
2042 mockHangUpData.SerialiseL(expectData); |
|
2043 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
2044 |
|
2045 completeData.Close(); |
|
2046 TMockLtsyCallData0 mockData3(callId, mobileService); |
|
2047 mockData3.SerialiseL(completeData); |
|
2048 iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); |
|
2049 // hangup the call |
|
2050 call.HangUp( status ); |
|
2051 User::WaitForRequest( status ); |
|
2052 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2053 |
|
2054 // change call status and check it is OK |
|
2055 UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting ); |
|
2056 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnecting ); |
|
2057 |
|
2058 // change call status and check it is OK |
|
2059 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2060 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
2061 |
|
2062 // cleanup |
|
2063 AssertMockLtsyStatusL(); |
|
2064 CleanupStack::PopAndDestroy( &call ); |
|
2065 AssertMockLtsyStatusL(); |
|
2066 CleanupStack::PopAndDestroy( &line ); |
|
2067 AssertMockLtsyStatusL(); |
|
2068 |
|
2069 DoCleanup(); |
|
2070 |
|
2071 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband |
|
2072 |
|
2073 DefinePropeties( ETrue, EVersion2 ); |
|
2074 OpenEtelServerL(EUseExtendedError); |
|
2075 OpenPhoneL(); |
|
2076 |
|
2077 // reset line & call |
|
2078 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2079 CleanupClosePushL( line ); |
|
2080 ASSERT_EQUALS( KErrNone, error ); |
|
2081 |
|
2082 error = call.OpenNewCall( line ); |
|
2083 CleanupClosePushL( call ); |
|
2084 ASSERT_EQUALS( KErrNone, error ); |
|
2085 |
|
2086 // prepare MockLTSY |
|
2087 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
2088 RMobileCall::TMobileCallInfoV8 callInfo2; |
|
2089 callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
2090 callInfo2.iService = mobileService; |
|
2091 callInfo2.iStatus = RMobileCall::EStatusUnknown; |
|
2092 callInfo2.iCallId =-1; |
|
2093 callInfo2.iExitCode =0; |
|
2094 callInfo2.iEmergency =0; |
|
2095 callInfo2.iForwarded =0; |
|
2096 callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
2097 callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
2098 callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
2099 callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
2100 callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
2101 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData6(0, mobileService, callParams, callInfo2); |
|
2102 mockData6.SerialiseL(expectData); |
|
2103 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
2104 mockData0.SerialiseL(completeData); |
|
2105 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
2106 |
|
2107 // dial the call |
|
2108 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
2109 User::WaitForRequest( status ); |
|
2110 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2111 |
|
2112 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2113 ASSERT_EQUALS( KErrNone, error ); |
|
2114 |
|
2115 // check that call status it is OK |
|
2116 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
2117 |
|
2118 // change call status and check it is OK |
|
2119 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
2120 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
2121 |
|
2122 // change call status and check it is OK |
|
2123 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2124 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
2125 |
|
2126 // change call status and check it is OK |
|
2127 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2128 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
2129 |
|
2130 // change call status and check it is OK |
|
2131 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
2132 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
2133 |
|
2134 // change call status and check it is OK |
|
2135 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2136 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
2137 |
|
2138 // cleanup |
|
2139 AssertMockLtsyStatusL(); |
|
2140 CleanupStack::PopAndDestroy( &call ); |
|
2141 AssertMockLtsyStatusL(); |
|
2142 CleanupStack::PopAndDestroy( &line ); |
|
2143 AssertMockLtsyStatusL(); |
|
2144 |
|
2145 DoCleanup(); |
|
2146 |
|
2147 // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting |
|
2148 |
|
2149 DefinePropeties( ETrue, EVersion2 ); |
|
2150 OpenEtelServerL(EUseExtendedError); |
|
2151 OpenPhoneL(); |
|
2152 |
|
2153 // reset line |
|
2154 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2155 CleanupClosePushL( line ); |
|
2156 ASSERT_EQUALS( KErrNone, error ); |
|
2157 |
|
2158 // notify incoming call |
|
2159 TName incomingCallName; |
|
2160 line.NotifyIncomingCall( status, incomingCallName ); |
|
2161 |
|
2162 // create incoming call notification |
|
2163 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo ); |
|
2164 mockCallData.SerialiseL( completeData ); |
|
2165 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2166 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
2167 User::WaitForRequest( mockLtsyStatus ); |
|
2168 AssertMockLtsyStatusL(); |
|
2169 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
2170 |
|
2171 // wait for notification |
|
2172 User::WaitForRequest( status ); |
|
2173 AssertMockLtsyStatusL(); |
|
2174 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2175 |
|
2176 // create call ringing notification |
|
2177 mobileCallStatus = RMobileCall::EStatusRinging; |
|
2178 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus ); |
|
2179 completeData.Close(); |
|
2180 mockCallData2.SerialiseL(completeData); |
|
2181 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
2182 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
2183 User::WaitForRequest(mockLtsyStatus); |
|
2184 AssertMockLtsyStatusL(); |
|
2185 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
2186 |
|
2187 // prepare MockLTSY for answer |
|
2188 expectData.Close(); |
|
2189 mockData0.SerialiseL( expectData ); |
|
2190 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
2191 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
2192 |
|
2193 // reset the call |
|
2194 error = call.OpenExistingCall( line, incomingCallName ); |
|
2195 CleanupClosePushL( call ); |
|
2196 ASSERT_EQUALS( KErrNone, error ); |
|
2197 |
|
2198 // answer the call |
|
2199 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
2200 User::WaitForRequest( status ); |
|
2201 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2202 |
|
2203 // change call status and check it is OK |
|
2204 UpdateCallStatusL( call, RMobileCall::EStatusAnswering ); |
|
2205 CheckCallStatus( incomingCallName, RMobileCall::EStatusAnswering ); |
|
2206 |
|
2207 // change call status and check it is OK |
|
2208 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2209 CheckCallStatus( incomingCallName, RMobileCall::EStatusConnecting ); |
|
2210 |
|
2211 // change call status and check it is OK |
|
2212 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2213 CheckCallStatus( incomingCallName, RMobileCall::EStatusConnected ); |
|
2214 |
|
2215 // prepare MockLTSY for hangup |
|
2216 expectData.Close(); |
|
2217 mockHangUpData.SerialiseL(expectData); |
|
2218 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
2219 |
|
2220 completeData.Close(); |
|
2221 TMockLtsyCallData0 mockData4(callId, mobileService); |
|
2222 mockData4.SerialiseL(completeData); |
|
2223 iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); |
|
2224 // hangup the call |
|
2225 call.HangUp( status ); |
|
2226 User::WaitForRequest( status ); |
|
2227 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2228 |
|
2229 // change call status and check it is OK |
|
2230 UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting ); |
|
2231 CheckCallStatus( incomingCallName, RMobileCall::EStatusDisconnecting ); |
|
2232 |
|
2233 // change call status and check it is OK |
|
2234 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2235 CheckCallStatus( incomingCallName, RMobileCall::EStatusIdle ); |
|
2236 |
|
2237 // cleanup |
|
2238 AssertMockLtsyStatusL(); |
|
2239 CleanupStack::PopAndDestroy( &call ); |
|
2240 AssertMockLtsyStatusL(); |
|
2241 CleanupStack::PopAndDestroy( &line ); |
|
2242 AssertMockLtsyStatusL(); |
|
2243 |
|
2244 DoCleanup(); |
|
2245 |
|
2246 // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband |
|
2247 |
|
2248 // reset properties |
|
2249 DefinePropeties( ETrue, EVersion2 ); |
|
2250 OpenEtelServerL(EUseExtendedError); |
|
2251 OpenPhoneL(); |
|
2252 |
|
2253 // reset line |
|
2254 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2255 CleanupClosePushL( line ); |
|
2256 ASSERT_EQUALS( KErrNone, error ); |
|
2257 |
|
2258 // notify incoming call |
|
2259 line.NotifyIncomingCall( status, incomingCallName ); |
|
2260 |
|
2261 // create incoming call notification |
|
2262 mockCallData.SerialiseL( completeData ); |
|
2263 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2264 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
2265 User::WaitForRequest( mockLtsyStatus ); |
|
2266 AssertMockLtsyStatusL(); |
|
2267 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
2268 |
|
2269 // wait for notification |
|
2270 User::WaitForRequest( status ); |
|
2271 AssertMockLtsyStatusL(); |
|
2272 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2273 |
|
2274 // create call ringing notification |
|
2275 completeData.Close(); |
|
2276 mockCallData2.SerialiseL(completeData); |
|
2277 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
2278 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
2279 User::WaitForRequest(mockLtsyStatus); |
|
2280 AssertMockLtsyStatusL(); |
|
2281 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
2282 |
|
2283 // prepare MockLTSY for answer |
|
2284 expectData.Close(); |
|
2285 mockData0.SerialiseL( expectData ); |
|
2286 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
2287 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
2288 |
|
2289 // reset the call |
|
2290 error = call.OpenExistingCall( line, incomingCallName ); |
|
2291 CleanupClosePushL( call ); |
|
2292 ASSERT_EQUALS( KErrNone, error ); |
|
2293 |
|
2294 // answer the call |
|
2295 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
2296 User::WaitForRequest( status ); |
|
2297 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2298 |
|
2299 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2300 ASSERT_EQUALS( KErrNone, error ); |
|
2301 |
|
2302 // change call status and check it is OK |
|
2303 UpdateCallStatusL( call, RMobileCall::EStatusAnswering ); |
|
2304 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering ); |
|
2305 |
|
2306 // change call status and check it is OK |
|
2307 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2308 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
2309 |
|
2310 // change call status and check it is OK |
|
2311 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2312 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
2313 |
|
2314 // change call status and check it is OK |
|
2315 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
2316 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
2317 |
|
2318 // change call status and check it is OK |
|
2319 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2320 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
2321 |
|
2322 // cleanup |
|
2323 AssertMockLtsyStatusL(); |
|
2324 CleanupStack::PopAndDestroy( &call ); |
|
2325 AssertMockLtsyStatusL(); |
|
2326 CleanupStack::PopAndDestroy( &line ); |
|
2327 AssertMockLtsyStatusL(); |
|
2328 |
|
2329 DoCleanup(); |
|
2330 |
|
2331 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusConnected -> EStatusDisconnectingWithInband -> EStatusIdle |
|
2332 |
|
2333 DefinePropeties( ETrue, EVersion2 ); |
|
2334 OpenEtelServerL(EUseExtendedError); |
|
2335 OpenPhoneL(); |
|
2336 |
|
2337 // reset line & call |
|
2338 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2339 CleanupClosePushL( line ); |
|
2340 ASSERT_EQUALS( KErrNone, error ); |
|
2341 |
|
2342 error = call.OpenNewCall( line ); |
|
2343 CleanupClosePushL( call ); |
|
2344 ASSERT_EQUALS( KErrNone, error ); |
|
2345 |
|
2346 // prepare MockLTSY |
|
2347 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
2348 mockData6.SerialiseL(expectData); |
|
2349 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
2350 mockData0.SerialiseL(completeData); |
|
2351 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
2352 |
|
2353 // dial the call |
|
2354 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
2355 User::WaitForRequest( status ); |
|
2356 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2357 |
|
2358 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2359 ASSERT_EQUALS( KErrNone, error ); |
|
2360 |
|
2361 // check that call status it is OK |
|
2362 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
2363 |
|
2364 // change call status and check it is OK |
|
2365 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
2366 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
2367 |
|
2368 // change call status and check it is OK |
|
2369 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2370 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
2371 |
|
2372 // change call status and check it is OK |
|
2373 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2374 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
2375 |
|
2376 // prepare MockLTSY for hold |
|
2377 expectData.Close(); |
|
2378 mockData0.SerialiseL(expectData); |
|
2379 iMockLTSY.ExpectL( EMobileCallHold, expectData ); |
|
2380 iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData ); |
|
2381 |
|
2382 call.Hold( status ); |
|
2383 User::WaitForRequest( status ); |
|
2384 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2385 |
|
2386 // change call status and check it is OK |
|
2387 UpdateCallStatusL( call, RMobileCall::EStatusHold ); |
|
2388 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusHold ); |
|
2389 |
|
2390 // prepare MockLTSY for resume |
|
2391 expectData.Close(); |
|
2392 mockData0.SerialiseL( expectData ); |
|
2393 iMockLTSY.ExpectL( EMobileCallResume, expectData ); |
|
2394 iMockLTSY.CompleteL( EMobileCallResume, KErrNone, expectData ); |
|
2395 |
|
2396 call.Resume( status ); |
|
2397 User::WaitForRequest( status ); |
|
2398 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2399 |
|
2400 // change call status and check it is OK |
|
2401 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2402 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
2403 |
|
2404 // change call status and check it is OK |
|
2405 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
2406 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
2407 |
|
2408 // change call status and check it is OK |
|
2409 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2410 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
2411 |
|
2412 // cleanup |
|
2413 AssertMockLtsyStatusL(); |
|
2414 CleanupStack::PopAndDestroy( &call ); |
|
2415 AssertMockLtsyStatusL(); |
|
2416 CleanupStack::PopAndDestroy( &line ); |
|
2417 AssertMockLtsyStatusL(); |
|
2418 |
|
2419 DoCleanup(); |
|
2420 |
|
2421 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusDisconnecting -> EStatusIdle |
|
2422 |
|
2423 DefinePropeties( ETrue, EVersion2 ); |
|
2424 OpenEtelServerL(EUseExtendedError); |
|
2425 OpenPhoneL(); |
|
2426 |
|
2427 // reset line & call |
|
2428 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2429 CleanupClosePushL( line ); |
|
2430 ASSERT_EQUALS( KErrNone, error ); |
|
2431 |
|
2432 error = call.OpenNewCall( line ); |
|
2433 CleanupClosePushL( call ); |
|
2434 ASSERT_EQUALS( KErrNone, error ); |
|
2435 |
|
2436 // prepare MockLTSY |
|
2437 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
2438 mockData6.SerialiseL(expectData); |
|
2439 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
2440 mockData0.SerialiseL(completeData); |
|
2441 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
2442 |
|
2443 // dial the call |
|
2444 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
2445 User::WaitForRequest( status ); |
|
2446 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2447 |
|
2448 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2449 ASSERT_EQUALS( KErrNone, error ); |
|
2450 |
|
2451 // check that call status it is OK |
|
2452 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
2453 |
|
2454 // change call status and check it is OK |
|
2455 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
2456 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
2457 |
|
2458 // change call status and check it is OK |
|
2459 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2460 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
2461 |
|
2462 // change call status and check it is OK |
|
2463 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2464 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
2465 |
|
2466 // prepare MockLTSY for hold |
|
2467 expectData.Close(); |
|
2468 mockData0.SerialiseL(expectData); |
|
2469 iMockLTSY.ExpectL( EMobileCallHold, expectData ); |
|
2470 iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData ); |
|
2471 |
|
2472 call.Hold( status ); |
|
2473 User::WaitForRequest( status ); |
|
2474 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2475 |
|
2476 // change call status and check it is OK |
|
2477 UpdateCallStatusL( call, RMobileCall::EStatusHold ); |
|
2478 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusHold ); |
|
2479 |
|
2480 // prepare MockLTSY for hangup |
|
2481 expectData.Close(); |
|
2482 mockHangUpData.SerialiseL(expectData); |
|
2483 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
2484 |
|
2485 completeData.Close(); |
|
2486 TMockLtsyCallData0 mockData5(callId, mobileService); |
|
2487 mockData5.SerialiseL(completeData); |
|
2488 iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); |
|
2489 // hangup the call |
|
2490 call.HangUp( status ); |
|
2491 User::WaitForRequest( status ); |
|
2492 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2493 |
|
2494 // change call status and check it is OK |
|
2495 UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting ); |
|
2496 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnecting ); |
|
2497 |
|
2498 // change call status and check it is OK |
|
2499 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2500 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
2501 |
|
2502 // cleanup |
|
2503 AssertMockLtsyStatusL(); |
|
2504 CleanupStack::PopAndDestroy( &call ); |
|
2505 AssertMockLtsyStatusL(); |
|
2506 CleanupStack::PopAndDestroy( &line ); |
|
2507 AssertMockLtsyStatusL(); |
|
2508 |
|
2509 DoCleanup(); |
|
2510 |
|
2511 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusDisconnectingWithInband -> EStatusIdle |
|
2512 |
|
2513 DefinePropeties( ETrue, EVersion2 ); |
|
2514 OpenEtelServerL(EUseExtendedError); |
|
2515 OpenPhoneL(); |
|
2516 |
|
2517 // reset line & call |
|
2518 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2519 CleanupClosePushL( line ); |
|
2520 ASSERT_EQUALS( KErrNone, error ); |
|
2521 |
|
2522 error = call.OpenNewCall( line ); |
|
2523 CleanupClosePushL( call ); |
|
2524 ASSERT_EQUALS( KErrNone, error ); |
|
2525 |
|
2526 // prepare MockLTSY |
|
2527 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
2528 mockData6.SerialiseL(expectData); |
|
2529 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
2530 mockData0.SerialiseL(completeData); |
|
2531 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
2532 |
|
2533 // dial the call |
|
2534 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
2535 User::WaitForRequest( status ); |
|
2536 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2537 |
|
2538 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2539 ASSERT_EQUALS( KErrNone, error ); |
|
2540 |
|
2541 // check that call status it is OK |
|
2542 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
2543 |
|
2544 // change call status and check it is OK |
|
2545 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
2546 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
2547 |
|
2548 // change call status and check it is OK |
|
2549 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2550 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
2551 |
|
2552 // change call status and check it is OK |
|
2553 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2554 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
2555 |
|
2556 // prepare MockLTSY for hold |
|
2557 expectData.Close(); |
|
2558 mockData0.SerialiseL(expectData); |
|
2559 iMockLTSY.ExpectL( EMobileCallHold, expectData ); |
|
2560 iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData ); |
|
2561 |
|
2562 call.Hold( status ); |
|
2563 User::WaitForRequest( status ); |
|
2564 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2565 |
|
2566 // change call status and check it is OK |
|
2567 UpdateCallStatusL( call, RMobileCall::EStatusHold ); |
|
2568 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusHold ); |
|
2569 |
|
2570 // change call status and check it is OK |
|
2571 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
2572 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
2573 |
|
2574 // change call status and check it is OK |
|
2575 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2576 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
2577 |
|
2578 // cleanup |
|
2579 AssertMockLtsyStatusL(); |
|
2580 CleanupStack::PopAndDestroy( &call ); |
|
2581 AssertMockLtsyStatusL(); |
|
2582 CleanupStack::PopAndDestroy( &line ); |
|
2583 AssertMockLtsyStatusL(); |
|
2584 |
|
2585 // cleanup |
|
2586 CleanupStack::PopAndDestroy( &completeData ); |
|
2587 CleanupStack::PopAndDestroy( &expectData ); |
|
2588 CleanupStack::PopAndDestroy( &data ); |
|
2589 CleanupStack::PopAndDestroy( this ); |
|
2590 } |
|
2591 |
|
2592 /** |
|
2593 @SYMTestCaseID BA-CTSY-CRC-CRCCRST-0001b |
|
2594 @SYMComponent telephony_ctsy |
|
2595 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::CallStateChange by using LTSY version1 |
|
2596 @SYMTestPriority High |
|
2597 @SYMTestActions Invokes MTelephonyAudioControl::CallStateChange |
|
2598 @SYMTestExpectedResults Pass |
|
2599 @SYMTestType CT |
|
2600 */ |
|
2601 void CCTsyTelephonyAudioControlFU::TestCallStateChange0001bL() |
|
2602 |
|
2603 { |
|
2604 |
|
2605 /* CallStateChange function is called when call has changed its state to the following states: |
|
2606 EStatusDialling |
|
2607 EStatusAnswering |
|
2608 EStatusConnecting |
|
2609 EStatusDisconnecting |
|
2610 EStatusDisconnectingWithInband |
|
2611 EStatusConnected |
|
2612 */ |
|
2613 DefinePropeties( ETrue, EVersion1 ); |
|
2614 |
|
2615 OpenEtelServerL(EUseExtendedError); |
|
2616 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
2617 OpenPhoneL(); |
|
2618 |
|
2619 RBuf8 data; |
|
2620 CleanupClosePushL(data); |
|
2621 |
|
2622 RBuf8 expectData; |
|
2623 CleanupClosePushL(expectData); |
|
2624 |
|
2625 RBuf8 completeData; |
|
2626 CleanupClosePushL(completeData); |
|
2627 |
|
2628 TRequestStatus status( KErrNone ); |
|
2629 TInt callId( 1 ); |
|
2630 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
2631 RMobileCall::TMobileCallParamsV7 callParams; |
|
2632 RMobileCall::TMobileCallInfoV8 callInfo; |
|
2633 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
2634 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
2635 callParams.iInterval = 100; |
|
2636 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
2637 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
2638 callParams.iCug.iExplicitInvoke = EFalse; |
|
2639 callParams.iCug.iCugIndex = 0xFFFF; |
|
2640 callParams.iCug.iSuppressPrefCug = EFalse; |
|
2641 callParams.iCug.iSuppressOA = EFalse; |
|
2642 callParams.iAutoRedial = EFalse; |
|
2643 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
2644 callInfo.iService = mobileService; |
|
2645 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
2646 callInfo.iCallId =-1; |
|
2647 callInfo.iExitCode =0; |
|
2648 callInfo.iEmergency =0; |
|
2649 callInfo.iForwarded =0; |
|
2650 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
2651 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
2652 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
2653 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
2654 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
2655 |
|
2656 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
2657 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
2658 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
2659 |
|
2660 RCall::TCallParams callParamsX1; |
|
2661 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
2662 |
|
2663 TRequestStatus mockLtsyStatus( KErrNone ); |
|
2664 RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting ); |
|
2665 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus ); |
|
2666 |
|
2667 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
2668 TBool autoStChangeDisable ( ETrue ); |
|
2669 |
|
2670 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
2671 |
|
2672 RLine line; |
|
2673 RMobileCall call; |
|
2674 |
|
2675 //------------------------------------------------------------------------- |
|
2676 // TEST C: Successful completion request of |
|
2677 // MTelephonyAudioControl::CallStateChange when result is not cached. |
|
2678 //------------------------------------------------------------------------- |
|
2679 |
|
2680 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting |
|
2681 |
|
2682 // reset line & call |
|
2683 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2684 CleanupClosePushL( line ); |
|
2685 ASSERT_EQUALS( KErrNone, error ); |
|
2686 |
|
2687 error = call.OpenNewCall( line ); |
|
2688 CleanupClosePushL( call ); |
|
2689 ASSERT_EQUALS( KErrNone, error ); |
|
2690 |
|
2691 // prepare MockLTSY |
|
2692 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
2693 mockData2.SerialiseL(expectData); |
|
2694 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
2695 mockData0.SerialiseL(completeData); |
|
2696 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
2697 |
|
2698 // dial the call |
|
2699 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
2700 User::WaitForRequest( status ); |
|
2701 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2702 |
|
2703 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2704 ASSERT_EQUALS( KErrNone, error ); |
|
2705 |
|
2706 // check that there is no call routing done |
|
2707 CheckNoCallRouting(); |
|
2708 |
|
2709 // change call status |
|
2710 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
2711 |
|
2712 // check that there is no call routing done |
|
2713 CheckNoCallRouting(); |
|
2714 |
|
2715 // change call status |
|
2716 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2717 |
|
2718 // check that there is no call routing done |
|
2719 CheckNoCallRouting(); |
|
2720 |
|
2721 // change call status |
|
2722 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2723 |
|
2724 // check that there is no call routing done |
|
2725 CheckNoCallRouting(); |
|
2726 |
|
2727 // prepare MockLTSY for hangup |
|
2728 expectData.Close(); |
|
2729 mockHangUpData.SerialiseL(expectData); |
|
2730 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
2731 |
|
2732 completeData.Close(); |
|
2733 TMockLtsyCallData0 mockData3(callId, mobileService); |
|
2734 mockData3.SerialiseL(completeData); |
|
2735 iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); |
|
2736 // hangup the call |
|
2737 call.HangUp( status ); |
|
2738 User::WaitForRequest( status ); |
|
2739 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2740 |
|
2741 // change call status |
|
2742 UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting ); |
|
2743 |
|
2744 // check that there is no call routing done |
|
2745 CheckNoCallRouting(); |
|
2746 |
|
2747 // change call status |
|
2748 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2749 |
|
2750 // check that there is no call routing done |
|
2751 CheckNoCallRouting(); |
|
2752 |
|
2753 // cleanup |
|
2754 AssertMockLtsyStatusL(); |
|
2755 CleanupStack::PopAndDestroy( &call ); |
|
2756 AssertMockLtsyStatusL(); |
|
2757 CleanupStack::PopAndDestroy( &line ); |
|
2758 AssertMockLtsyStatusL(); |
|
2759 |
|
2760 DoCleanup(); |
|
2761 |
|
2762 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband |
|
2763 |
|
2764 DefinePropeties( ETrue, EVersion1 ); |
|
2765 OpenEtelServerL(EUseExtendedError); |
|
2766 OpenPhoneL(); |
|
2767 |
|
2768 // reset line & call |
|
2769 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2770 CleanupClosePushL( line ); |
|
2771 ASSERT_EQUALS( KErrNone, error ); |
|
2772 |
|
2773 error = call.OpenNewCall( line ); |
|
2774 CleanupClosePushL( call ); |
|
2775 ASSERT_EQUALS( KErrNone, error ); |
|
2776 |
|
2777 // prepare MockLTSY |
|
2778 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
2779 RMobileCall::TMobileCallInfoV8 callInfo2; |
|
2780 callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
2781 callInfo2.iService = mobileService; |
|
2782 callInfo2.iStatus = RMobileCall::EStatusUnknown; |
|
2783 callInfo2.iCallId =-1; |
|
2784 callInfo2.iExitCode =0; |
|
2785 callInfo2.iEmergency =0; |
|
2786 callInfo2.iForwarded =0; |
|
2787 callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
2788 callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
2789 callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
2790 callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
2791 callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
2792 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData5(0, mobileService, callParams, callInfo2); |
|
2793 mockData5.SerialiseL(expectData); |
|
2794 |
|
2795 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
2796 mockData0.SerialiseL(completeData); |
|
2797 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
2798 |
|
2799 // dial the call |
|
2800 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
2801 User::WaitForRequest( status ); |
|
2802 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2803 |
|
2804 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2805 ASSERT_EQUALS( KErrNone, error ); |
|
2806 |
|
2807 // check that there is no call routing done |
|
2808 CheckNoCallRouting(); |
|
2809 |
|
2810 // change call status |
|
2811 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
2812 |
|
2813 // check that there is no call routing done |
|
2814 CheckNoCallRouting(); |
|
2815 |
|
2816 // change call status |
|
2817 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2818 |
|
2819 // check that there is no call routing done |
|
2820 CheckNoCallRouting(); |
|
2821 |
|
2822 // change call status |
|
2823 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2824 |
|
2825 // check that there is no call routing done |
|
2826 CheckNoCallRouting(); |
|
2827 |
|
2828 // change call status |
|
2829 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
2830 |
|
2831 // check that there is no call routing done |
|
2832 CheckNoCallRouting(); |
|
2833 |
|
2834 // change call status |
|
2835 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2836 |
|
2837 // check that there is no call routing done |
|
2838 CheckNoCallRouting(); |
|
2839 |
|
2840 // cleanup |
|
2841 AssertMockLtsyStatusL(); |
|
2842 CleanupStack::PopAndDestroy( &call ); |
|
2843 AssertMockLtsyStatusL(); |
|
2844 CleanupStack::PopAndDestroy( &line ); |
|
2845 AssertMockLtsyStatusL(); |
|
2846 |
|
2847 DoCleanup(); |
|
2848 |
|
2849 // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting |
|
2850 |
|
2851 DefinePropeties( ETrue, EVersion1 ); |
|
2852 OpenEtelServerL(EUseExtendedError); |
|
2853 OpenPhoneL(); |
|
2854 |
|
2855 // reset line |
|
2856 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2857 CleanupClosePushL( line ); |
|
2858 ASSERT_EQUALS( KErrNone, error ); |
|
2859 |
|
2860 // notify incoming call |
|
2861 TName incomingCallName; |
|
2862 line.NotifyIncomingCall( status, incomingCallName ); |
|
2863 |
|
2864 // create incoming call notification |
|
2865 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo ); |
|
2866 mockCallData.SerialiseL( completeData ); |
|
2867 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2868 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
2869 User::WaitForRequest( mockLtsyStatus ); |
|
2870 AssertMockLtsyStatusL(); |
|
2871 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
2872 |
|
2873 // wait for notification |
|
2874 User::WaitForRequest( status ); |
|
2875 AssertMockLtsyStatusL(); |
|
2876 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2877 |
|
2878 // create call ringing notification |
|
2879 mobileCallStatus = RMobileCall::EStatusRinging; |
|
2880 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus ); |
|
2881 completeData.Close(); |
|
2882 mockCallData2.SerialiseL(completeData); |
|
2883 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
2884 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
2885 User::WaitForRequest(mockLtsyStatus); |
|
2886 AssertMockLtsyStatusL(); |
|
2887 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
2888 |
|
2889 // prepare MockLTSY for answer |
|
2890 expectData.Close(); |
|
2891 mockData0.SerialiseL( expectData ); |
|
2892 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
2893 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
2894 |
|
2895 // reset the call |
|
2896 error = call.OpenExistingCall( line, incomingCallName ); |
|
2897 CleanupClosePushL( call ); |
|
2898 ASSERT_EQUALS( KErrNone, error ); |
|
2899 |
|
2900 // check that there is no call routing done |
|
2901 CheckNoCallRouting(); |
|
2902 |
|
2903 // answer the call |
|
2904 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
2905 User::WaitForRequest( status ); |
|
2906 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2907 |
|
2908 // check that there is no call routing done |
|
2909 CheckNoCallRouting(); |
|
2910 |
|
2911 error = call.GetMobileCallInfo( callInfoPckg ); |
|
2912 ASSERT_EQUALS( KErrNone, error ); |
|
2913 |
|
2914 // change call status |
|
2915 UpdateCallStatusL( call, RMobileCall::EStatusAnswering ); |
|
2916 |
|
2917 // check that there is no call routing done |
|
2918 CheckNoCallRouting(); |
|
2919 |
|
2920 // change call status |
|
2921 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
2922 |
|
2923 // check that there is no call routing done |
|
2924 CheckNoCallRouting(); |
|
2925 |
|
2926 // change call status |
|
2927 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
2928 |
|
2929 // check that there is no call routing done |
|
2930 CheckNoCallRouting(); |
|
2931 |
|
2932 // prepare MockLTSY for hangup |
|
2933 expectData.Close(); |
|
2934 mockHangUpData.SerialiseL(expectData); |
|
2935 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
2936 |
|
2937 completeData.Close(); |
|
2938 TMockLtsyCallData0 mockData4(callId, mobileService); |
|
2939 mockData4.SerialiseL(completeData); |
|
2940 iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); |
|
2941 // hangup the call |
|
2942 call.HangUp( status ); |
|
2943 User::WaitForRequest( status ); |
|
2944 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2945 |
|
2946 // change call status |
|
2947 UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting ); |
|
2948 |
|
2949 // check that there is no call routing done |
|
2950 CheckNoCallRouting(); |
|
2951 |
|
2952 // change call status |
|
2953 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
2954 |
|
2955 // check that there is no call routing done |
|
2956 CheckNoCallRouting(); |
|
2957 |
|
2958 // cleanup |
|
2959 AssertMockLtsyStatusL(); |
|
2960 CleanupStack::PopAndDestroy( &call ); |
|
2961 AssertMockLtsyStatusL(); |
|
2962 CleanupStack::PopAndDestroy( &line ); |
|
2963 AssertMockLtsyStatusL(); |
|
2964 |
|
2965 DoCleanup(); |
|
2966 |
|
2967 // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband |
|
2968 |
|
2969 DefinePropeties( ETrue, EVersion1 ); |
|
2970 OpenEtelServerL(EUseExtendedError); |
|
2971 OpenPhoneL(); |
|
2972 |
|
2973 // reset line |
|
2974 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
2975 CleanupClosePushL( line ); |
|
2976 ASSERT_EQUALS( KErrNone, error ); |
|
2977 |
|
2978 // notify incoming call |
|
2979 line.NotifyIncomingCall( status, incomingCallName ); |
|
2980 |
|
2981 // create incoming call notification |
|
2982 mockCallData.SerialiseL( completeData ); |
|
2983 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2984 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
2985 User::WaitForRequest( mockLtsyStatus ); |
|
2986 AssertMockLtsyStatusL(); |
|
2987 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
2988 |
|
2989 // wait for notification |
|
2990 User::WaitForRequest( status ); |
|
2991 AssertMockLtsyStatusL(); |
|
2992 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
2993 |
|
2994 // create call ringing notification |
|
2995 completeData.Close(); |
|
2996 mockCallData2.SerialiseL(completeData); |
|
2997 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
2998 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
2999 User::WaitForRequest(mockLtsyStatus); |
|
3000 AssertMockLtsyStatusL(); |
|
3001 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
3002 |
|
3003 // prepare MockLTSY for answer |
|
3004 expectData.Close(); |
|
3005 mockData0.SerialiseL( expectData ); |
|
3006 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
3007 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
3008 |
|
3009 // reset the call |
|
3010 error = call.OpenExistingCall( line, incomingCallName ); |
|
3011 CleanupClosePushL( call ); |
|
3012 ASSERT_EQUALS( KErrNone, error ); |
|
3013 |
|
3014 // check that there is no call routing done |
|
3015 CheckNoCallRouting(); |
|
3016 |
|
3017 // answer the call |
|
3018 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
3019 User::WaitForRequest( status ); |
|
3020 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3021 |
|
3022 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3023 ASSERT_EQUALS( KErrNone, error ); |
|
3024 |
|
3025 // change call status |
|
3026 UpdateCallStatusL( call, RMobileCall::EStatusAnswering ); |
|
3027 |
|
3028 // check that there is no call routing done |
|
3029 CheckNoCallRouting(); |
|
3030 |
|
3031 // change call status |
|
3032 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
3033 |
|
3034 // check that there is no call routing done |
|
3035 CheckNoCallRouting(); |
|
3036 |
|
3037 // change call status |
|
3038 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
3039 |
|
3040 // check that there is no call routing done |
|
3041 CheckNoCallRouting(); |
|
3042 |
|
3043 // change call status |
|
3044 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
3045 |
|
3046 // check that there is no call routing done |
|
3047 CheckNoCallRouting(); |
|
3048 |
|
3049 // change call status |
|
3050 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
3051 |
|
3052 // check that there is no call routing done |
|
3053 CheckNoCallRouting(); |
|
3054 |
|
3055 // cleanup |
|
3056 AssertMockLtsyStatusL(); |
|
3057 CleanupStack::PopAndDestroy( &call ); |
|
3058 AssertMockLtsyStatusL(); |
|
3059 CleanupStack::PopAndDestroy( &line ); |
|
3060 AssertMockLtsyStatusL(); |
|
3061 |
|
3062 DoCleanup(); |
|
3063 |
|
3064 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusDisconnectingWithInband -> EStatusIdle |
|
3065 |
|
3066 DefinePropeties( ETrue, EVersion1 ); |
|
3067 OpenEtelServerL(EUseExtendedError); |
|
3068 OpenPhoneL(); |
|
3069 |
|
3070 // reset line & call |
|
3071 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
3072 CleanupClosePushL( line ); |
|
3073 ASSERT_EQUALS( KErrNone, error ); |
|
3074 |
|
3075 error = call.OpenNewCall( line ); |
|
3076 CleanupClosePushL( call ); |
|
3077 ASSERT_EQUALS( KErrNone, error ); |
|
3078 |
|
3079 // prepare MockLTSY |
|
3080 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
3081 mockData5.SerialiseL(expectData); |
|
3082 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
3083 mockData0.SerialiseL(completeData); |
|
3084 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
3085 |
|
3086 // dial the call |
|
3087 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
3088 User::WaitForRequest( status ); |
|
3089 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3090 |
|
3091 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3092 ASSERT_EQUALS( KErrNone, error ); |
|
3093 |
|
3094 // check that there is no call routing done |
|
3095 CheckNoCallRouting(); |
|
3096 |
|
3097 // change call status |
|
3098 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
3099 |
|
3100 // check that there is no call routing done |
|
3101 CheckNoCallRouting(); |
|
3102 |
|
3103 // change call status |
|
3104 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
3105 |
|
3106 // check that there is no call routing done |
|
3107 CheckNoCallRouting(); |
|
3108 |
|
3109 // change call status |
|
3110 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
3111 |
|
3112 // check that there is no call routing done |
|
3113 CheckNoCallRouting(); |
|
3114 |
|
3115 // prepare MockLTSY for hold |
|
3116 expectData.Close(); |
|
3117 mockData0.SerialiseL(expectData); |
|
3118 iMockLTSY.ExpectL( EMobileCallHold, expectData ); |
|
3119 iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData ); |
|
3120 |
|
3121 call.Hold( status ); |
|
3122 User::WaitForRequest( status ); |
|
3123 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3124 |
|
3125 // change call status |
|
3126 UpdateCallStatusL( call, RMobileCall::EStatusHold ); |
|
3127 |
|
3128 // check that there is no call routing done |
|
3129 CheckNoCallRouting(); |
|
3130 |
|
3131 // change call status |
|
3132 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband ); |
|
3133 |
|
3134 // check that there is no call routing done |
|
3135 CheckNoCallRouting(); |
|
3136 |
|
3137 // change call status |
|
3138 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
3139 |
|
3140 // check that there is no call routing done |
|
3141 CheckNoCallRouting(); |
|
3142 |
|
3143 // cleanup |
|
3144 AssertMockLtsyStatusL(); |
|
3145 CleanupStack::PopAndDestroy( &call ); |
|
3146 AssertMockLtsyStatusL(); |
|
3147 CleanupStack::PopAndDestroy( &line ); |
|
3148 AssertMockLtsyStatusL(); |
|
3149 |
|
3150 // cleanup |
|
3151 CleanupStack::PopAndDestroy( &completeData ); |
|
3152 CleanupStack::PopAndDestroy( &expectData ); |
|
3153 CleanupStack::PopAndDestroy( &data ); |
|
3154 CleanupStack::PopAndDestroy( this ); |
|
3155 |
|
3156 } |
|
3157 |
|
3158 /** |
|
3159 @SYMTestCaseID BA-CTSY-CRC-CRCCRST-0004 |
|
3160 @SYMComponent telephony_ctsy |
|
3161 @SYMTestCaseDesc Test support in CTSY for multiple client requests to MTelephonyAudioControl::CallStateChange |
|
3162 @SYMTestPriority High |
|
3163 @SYMTestActions Invokes multiple client requests to MTelephonyAudioControl::CallStateChange |
|
3164 @SYMTestExpectedResults Pass |
|
3165 @SYMTestType CT |
|
3166 */ |
|
3167 void CCTsyTelephonyAudioControlFU::TestCallStateChange0004L() |
|
3168 { |
|
3169 DefinePropeties( EFalse, EVersion2 ); |
|
3170 |
|
3171 OpenEtelServerL(EUseExtendedError); |
|
3172 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
3173 OpenPhoneL(); |
|
3174 |
|
3175 RBuf8 data; |
|
3176 CleanupClosePushL(data); |
|
3177 |
|
3178 RBuf8 expectData; |
|
3179 CleanupClosePushL(expectData); |
|
3180 |
|
3181 RBuf8 completeData; |
|
3182 CleanupClosePushL(completeData); |
|
3183 |
|
3184 TRequestStatus status( KErrNone ); |
|
3185 TInt callId( 1 ); |
|
3186 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
3187 RMobileCall::TMobileCallParamsV7 callParams; |
|
3188 RMobileCall::TMobileCallInfoV8 callInfo; |
|
3189 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
3190 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
3191 callParams.iInterval = 100; |
|
3192 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
3193 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
3194 callParams.iCug.iExplicitInvoke = EFalse; |
|
3195 callParams.iCug.iCugIndex = 0xFFFF; |
|
3196 callParams.iCug.iSuppressPrefCug = EFalse; |
|
3197 callParams.iCug.iSuppressOA = EFalse; |
|
3198 callParams.iAutoRedial = EFalse; |
|
3199 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
3200 callInfo.iService = mobileService; |
|
3201 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
3202 callInfo.iCallId =-1; |
|
3203 callInfo.iExitCode =0; |
|
3204 callInfo.iEmergency =0; |
|
3205 callInfo.iForwarded =0; |
|
3206 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
3207 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
3208 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
3209 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
3210 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
3211 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
3212 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
3213 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
3214 |
|
3215 RCall::TCallParams callParamsX1; |
|
3216 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
3217 |
|
3218 TRequestStatus mockLtsyStatus( KErrNone ); |
|
3219 RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting ); |
|
3220 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus ); |
|
3221 |
|
3222 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
3223 TBool autoStChangeDisable ( ETrue ); |
|
3224 |
|
3225 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
3226 |
|
3227 RLine line; |
|
3228 RMobileCall call; |
|
3229 |
|
3230 //------------------------------------------------------------------------- |
|
3231 // Test A: Test multiple clients requesting MTelephonyAudioControl::CallStateChange |
|
3232 //------------------------------------------------------------------------- |
|
3233 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband -> EStatusIdle |
|
3234 |
|
3235 // reset line & call |
|
3236 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
3237 CleanupClosePushL( line ); |
|
3238 ASSERT_EQUALS( KErrNone, error ); |
|
3239 |
|
3240 error = call.OpenNewCall( line ); |
|
3241 CleanupClosePushL( call ); |
|
3242 ASSERT_EQUALS( KErrNone, error ); |
|
3243 |
|
3244 // prepare MockLTSY |
|
3245 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
3246 mockData2.SerialiseL(expectData); |
|
3247 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
3248 mockData0.SerialiseL(completeData); |
|
3249 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
3250 |
|
3251 // dial the call |
|
3252 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
3253 User::WaitForRequest( status ); |
|
3254 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3255 |
|
3256 AssertMockLtsyStatusL(); |
|
3257 |
|
3258 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3259 ASSERT_EQUALS( KErrNone, error ); |
|
3260 |
|
3261 // check that call status it is OK |
|
3262 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
3263 |
|
3264 // change call status and check it is OK |
|
3265 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
3266 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
3267 |
|
3268 AssertMockLtsyStatusL(); |
|
3269 |
|
3270 // change call status and check it is OK |
|
3271 UpdateCallStatusL( call, RMobileCall::EStatusConnecting ); |
|
3272 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
3273 |
|
3274 AssertMockLtsyStatusL(); |
|
3275 |
|
3276 // change call status and check it is OK |
|
3277 UpdateCallStatusL( call, RMobileCall::EStatusConnected ); |
|
3278 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
3279 |
|
3280 AssertMockLtsyStatusL(); |
|
3281 |
|
3282 // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting |
|
3283 |
|
3284 // Open second client |
|
3285 RTelServer telServer2; |
|
3286 error = telServer2.Connect(); |
|
3287 ASSERT_EQUALS( KErrNone, error ); |
|
3288 CleanupClosePushL( telServer2 ); |
|
3289 |
|
3290 RMobilePhone phone2; |
|
3291 error = phone2.Open( telServer2,KMmTsyPhoneName ); |
|
3292 ASSERT_EQUALS( KErrNone, error ); |
|
3293 CleanupClosePushL( phone2 ); |
|
3294 |
|
3295 RLine line2; |
|
3296 error = line2.Open( phone2, KMmTsyVoice1LineName ); |
|
3297 CleanupClosePushL( line2 ); |
|
3298 ASSERT_EQUALS( KErrNone, error ); |
|
3299 |
|
3300 RMobileCall call2; |
|
3301 error = call2.OpenNewCall( line2 ); |
|
3302 CleanupClosePushL( call2 ); |
|
3303 ASSERT_EQUALS( KErrNone, error ); |
|
3304 |
|
3305 TInt callId2( 2 ); |
|
3306 // prepare MockLTSY for call 2 dial |
|
3307 TMockLtsyCallData0 mockData01(callId2, mobileService); |
|
3308 CallGetMobileCallInfoL(callId2, mobileService, KPhoneNumber); |
|
3309 RMobileCall::TMobileCallInfoV8 callInfo2; |
|
3310 callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
3311 callInfo2.iService = mobileService; |
|
3312 callInfo2.iStatus = RMobileCall::EStatusUnknown; |
|
3313 callInfo2.iCallId =-1; |
|
3314 callInfo2.iExitCode =0; |
|
3315 callInfo2.iEmergency =0; |
|
3316 callInfo2.iForwarded =0; |
|
3317 callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
3318 callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
3319 callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
3320 callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
3321 callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
3322 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService, callParams, callInfo2); |
|
3323 mockData3.SerialiseL(expectData); |
|
3324 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
3325 mockData01.SerialiseL(completeData); |
|
3326 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
3327 |
|
3328 // make the call 2 |
|
3329 call2.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
3330 User::WaitForRequest( status ); |
|
3331 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3332 |
|
3333 AssertMockLtsyStatusL(); |
|
3334 |
|
3335 error = call2.GetMobileCallInfo( callInfoPckg ); |
|
3336 ASSERT_EQUALS( KErrNone, error ); |
|
3337 |
|
3338 // check that call status it is OK |
|
3339 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown ); |
|
3340 |
|
3341 // change call status and check it is OK |
|
3342 UpdateCallStatusL( call2, RMobileCall::EStatusDialling ); |
|
3343 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
3344 |
|
3345 AssertMockLtsyStatusL(); |
|
3346 |
|
3347 // change call status and check it is OK |
|
3348 UpdateCallStatusL( call2, RMobileCall::EStatusConnecting ); |
|
3349 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
3350 |
|
3351 AssertMockLtsyStatusL(); |
|
3352 |
|
3353 // change call status and check it is OK |
|
3354 UpdateCallStatusL( call2, RMobileCall::EStatusConnected ); |
|
3355 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
3356 |
|
3357 TInt callCount(0); |
|
3358 error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
3359 ASSERT_EQUALS( KErrNone, error ); |
|
3360 |
|
3361 // there should be 2 calls now |
|
3362 ASSERT_EQUALS( 2, callCount ); |
|
3363 |
|
3364 // hangup call 1 |
|
3365 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3366 ASSERT_EQUALS( KErrNone, error ); |
|
3367 UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband, ETrue ); |
|
3368 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
3369 |
|
3370 // change call status and check it is OK |
|
3371 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue ); |
|
3372 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
3373 |
|
3374 error = call2.GetMobileCallInfo( callInfoPckg ); |
|
3375 ASSERT_EQUALS( KErrNone, error ); |
|
3376 |
|
3377 // hangup call 2 |
|
3378 // change call status and check it is OK |
|
3379 UpdateCallStatusL( call2, RMobileCall::EStatusDisconnectingWithInband, ETrue ); |
|
3380 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband ); |
|
3381 |
|
3382 // change call status and check it is OK |
|
3383 UpdateCallStatusL( call2, RMobileCall::EStatusIdle, ETrue ); |
|
3384 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
3385 |
|
3386 // cleanup |
|
3387 CleanupStack::PopAndDestroy( &call2 ); |
|
3388 CleanupStack::PopAndDestroy( &line2 ); |
|
3389 CleanupStack::PopAndDestroy( &phone2 ); |
|
3390 CleanupStack::PopAndDestroy( &telServer2 ); |
|
3391 CleanupStack::PopAndDestroy( &call ); |
|
3392 CleanupStack::PopAndDestroy( &line ); |
|
3393 CleanupStack::PopAndDestroy( &completeData ); |
|
3394 CleanupStack::PopAndDestroy( &expectData ); |
|
3395 CleanupStack::PopAndDestroy( &data ); |
|
3396 CleanupStack::PopAndDestroy( this ); |
|
3397 } |
|
3398 |
|
3399 void CCTsyTelephonyAudioControlFU::UpdateCallStatusL( RMobileCall& aMobileCall, |
|
3400 RMobileCall::TMobileCallStatus aMobileCallStatus, |
|
3401 TBool aUpdateTimer, |
|
3402 TBool aHangUp ) |
|
3403 { |
|
3404 RMobileCall::TMobileCallInfoV1 callInfo; |
|
3405 RMobileCall::TMobileCallInfoV1Pckg callInfoPckg( callInfo ); |
|
3406 TInt error = aMobileCall.GetMobileCallInfo( callInfoPckg ); |
|
3407 ASSERT_EQUALS( KErrNone, error ); |
|
3408 |
|
3409 RBuf8 completeData; |
|
3410 CleanupClosePushL(completeData); |
|
3411 |
|
3412 RBuf8 expectData; |
|
3413 CleanupClosePushL(expectData); |
|
3414 |
|
3415 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callInfo.iCallId, callInfo.iService, aMobileCallStatus ); |
|
3416 completeData.Close(); |
|
3417 mockCallData.SerialiseL(completeData); |
|
3418 |
|
3419 TRequestStatus mockLtsyStatus( KErrNone ); |
|
3420 |
|
3421 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
3422 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData ); |
|
3423 |
|
3424 if ( aHangUp ) |
|
3425 { |
|
3426 TInt callId( 1 ); |
|
3427 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
3428 RMobileCall::TMobileCallParamsV1 callParams; |
|
3429 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
3430 TBool autoStChangeDisable ( ETrue ); |
|
3431 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
3432 expectData.Close(); |
|
3433 mockHangUpData.SerialiseL(expectData); |
|
3434 iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone ); |
|
3435 } |
|
3436 |
|
3437 if ( aUpdateTimer ) |
|
3438 { |
|
3439 // when call becomes idle, remaining duration of the call is added to life time param in LTSY: |
|
3440 TUint32 duration = 9; // this is a dummy value, which won't be checked by mocksy engine |
|
3441 TMockLtsyData1<TUint32> timerData( duration ); |
|
3442 expectData.Close(); |
|
3443 timerData.SerialiseL(expectData); |
|
3444 iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, expectData); |
|
3445 } |
|
3446 |
|
3447 User::WaitForRequest(mockLtsyStatus); |
|
3448 |
|
3449 AssertMockLtsyStatusL(); |
|
3450 |
|
3451 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int() ); |
|
3452 |
|
3453 CleanupStack::PopAndDestroy( &expectData ); |
|
3454 CleanupStack::PopAndDestroy( &completeData ); |
|
3455 |
|
3456 error = aMobileCall.GetMobileCallInfo( callInfoPckg ); |
|
3457 ASSERT_EQUALS( KErrNone, error ); |
|
3458 } |
|
3459 |
|
3460 void CCTsyTelephonyAudioControlFU::CheckCallRoutingValues( RLine& aLine, RMobileCall& aCall ) |
|
3461 { |
|
3462 TInt callCount(0); |
|
3463 TInt error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
3464 ASSERT_EQUALS( KErrNone, error ); |
|
3465 |
|
3466 TInt count(0); |
|
3467 error = aLine.EnumerateCall( count ); |
|
3468 ASSERT_EQUALS( KErrNone, error ); |
|
3469 ASSERT_EQUALS( callCount, count ); |
|
3470 |
|
3471 RMobileCall::TMobileCallInfoV1 callInfo; |
|
3472 RMobileCall::TMobileCallInfoV1Pckg callInfoPckg( callInfo ); |
|
3473 error = aCall.GetMobileCallInfo( callInfoPckg ); |
|
3474 ASSERT_EQUALS( KErrNone, error ); |
|
3475 |
|
3476 TName callName; |
|
3477 error = RProperty::Get( KMockLtsyFactoryProperty, ECallName, callName ); |
|
3478 ASSERT_EQUALS( KErrNone, error ); |
|
3479 ASSERT_EQUALS( 0, callInfo.iCallName.Compare( callName ) ); |
|
3480 |
|
3481 TBool emergency( ETrue ); |
|
3482 error = RProperty::Get( KMockLtsyFactoryProperty, EEmergencyCall, emergency ); |
|
3483 ASSERT_EQUALS( KErrNone, error ); |
|
3484 ASSERT_EQUALS( emergency, callInfo.iEmergency ); |
|
3485 |
|
3486 TInt direction(0); |
|
3487 error = RProperty::Get( KMockLtsyFactoryProperty, ECallDirection, direction ); |
|
3488 RMobileCall::TMobileCallDirection calldirection = (RMobileCall::TMobileCallDirection) direction; |
|
3489 ASSERT_EQUALS( KErrNone, error ); |
|
3490 ASSERT_EQUALS( calldirection, callInfo.iRemoteParty.iDirection ); |
|
3491 |
|
3492 TInt callType( 0 ); |
|
3493 error = RProperty::Get( KMockLtsyFactoryProperty, ECallType, callType ); |
|
3494 MTelephonyAudioControl::TTelephonyAudioControlCallType callRoutingType = ( MTelephonyAudioControl::TTelephonyAudioControlCallType ) callType; |
|
3495 ASSERT_EQUALS( KErrNone, error ); |
|
3496 ASSERT_EQUALS( callRoutingType, MTelephonyAudioControl::ECallTypeVoice ); |
|
3497 } |
|
3498 |
|
3499 |
|
3500 void CCTsyTelephonyAudioControlFU::DefinePropeties( TBool aReset, TMockLtsyFactoryVersions aVersion ) |
|
3501 { |
|
3502 DeletePropeties(); |
|
3503 |
|
3504 TInt error = RProperty::Define( KMockLtsyFactoryProperty, ENumberOfCalls, RProperty::EInt ); |
|
3505 ASSERT_EQUALS( KErrNone, error ); |
|
3506 |
|
3507 error = RProperty::Define( KMockLtsyFactoryProperty, ECallName, RProperty::EText ); |
|
3508 ASSERT_EQUALS( KErrNone, error ); |
|
3509 |
|
3510 error = RProperty::Define( KMockLtsyFactoryProperty, EEmergencyCall, RProperty::EInt ); |
|
3511 ASSERT_EQUALS( KErrNone, error ); |
|
3512 |
|
3513 error = RProperty::Define( KMockLtsyFactoryProperty, ECallDirection, RProperty::EInt ); |
|
3514 ASSERT_EQUALS( KErrNone, error ); |
|
3515 |
|
3516 error = RProperty::Define( KMockLtsyFactoryProperty, EHangUpReason, RProperty::EInt ); |
|
3517 ASSERT_EQUALS( KErrNone, error ); |
|
3518 |
|
3519 error = RProperty::Define( KMockLtsyFactoryProperty, ECallType, RProperty::EInt ); |
|
3520 ASSERT_EQUALS( KErrNone, error ); |
|
3521 |
|
3522 error = RProperty::Define( KMockLtsyFactoryProperty, EReturnErrorCode, RProperty::EInt ); |
|
3523 ASSERT_EQUALS( KErrNone, error ); |
|
3524 |
|
3525 error = RProperty::Define( KMockLtsyFactoryProperty, EReset, RProperty::EInt ); |
|
3526 ASSERT_EQUALS( KErrNone, error ); |
|
3527 |
|
3528 error = RProperty::Define( KMockLtsyFactoryProperty, ECallStatus, RProperty::EInt ); |
|
3529 ASSERT_EQUALS( KErrNone, error ); |
|
3530 |
|
3531 error = RProperty::Set( KMockLtsyFactoryProperty, EReset, aReset ); |
|
3532 ASSERT_EQUALS( KErrNone, error ); |
|
3533 |
|
3534 error = RProperty::Define( KMockLtsyFactoryProperty, EVersionProperty, RProperty::EInt ); |
|
3535 ASSERT_EQUALS( KErrNone, error ); |
|
3536 |
|
3537 error = RProperty::Set( KMockLtsyFactoryProperty, EVersionProperty, aVersion ); |
|
3538 ASSERT_EQUALS( KErrNone, error ); |
|
3539 |
|
3540 error = RProperty::Define( KMockLtsyFactoryProperty, EComplete, RProperty::EInt ); |
|
3541 ASSERT_EQUALS( KErrNone, error ); |
|
3542 |
|
3543 error = RProperty::Set( KMockLtsyFactoryProperty, EComplete, EFalse ); |
|
3544 ASSERT_EQUALS( KErrNone, error ); |
|
3545 } |
|
3546 |
|
3547 |
|
3548 void CCTsyTelephonyAudioControlFU::CheckCallStatus( TName& aCallName, RMobileCall::TMobileCallStatus aMobileCallStatus ) |
|
3549 { |
|
3550 TName callName; |
|
3551 TInt error = RProperty::Get( KMockLtsyFactoryProperty, ECallName, callName ); |
|
3552 ASSERT_EQUALS( KErrNone, error ); |
|
3553 ASSERT_EQUALS( 0, aCallName.Compare( callName ) ); |
|
3554 |
|
3555 TInt status( 0 ); |
|
3556 error = RProperty::Get( KMockLtsyFactoryProperty, ECallStatus, status ); |
|
3557 RMobileCall::TMobileCallStatus callStatus = ( RMobileCall::TMobileCallStatus ) status; |
|
3558 ASSERT_EQUALS( KErrNone, error ); |
|
3559 ASSERT_EQUALS( callStatus, aMobileCallStatus ); |
|
3560 } |
|
3561 |
|
3562 void CCTsyTelephonyAudioControlFU::DeletePropeties() |
|
3563 { |
|
3564 TInt error = RProperty::Delete(KMockLtsyFactoryProperty, ENumberOfCalls ); |
|
3565 error = RProperty::Delete(KMockLtsyFactoryProperty, ECallName ); |
|
3566 error = RProperty::Delete(KMockLtsyFactoryProperty, EEmergencyCall ); |
|
3567 error = RProperty::Delete(KMockLtsyFactoryProperty, ECallDirection ); |
|
3568 error = RProperty::Delete(KMockLtsyFactoryProperty, EHangUpReason ); |
|
3569 error = RProperty::Delete(KMockLtsyFactoryProperty, ECallType ); |
|
3570 error = RProperty::Delete(KMockLtsyFactoryProperty, EReturnErrorCode ); |
|
3571 error = RProperty::Delete(KMockLtsyFactoryProperty, EReset ); |
|
3572 error = RProperty::Delete(KMockLtsyFactoryProperty, ECallStatus ); |
|
3573 error = RProperty::Delete(KMockLtsyFactoryProperty, EVersionProperty ); |
|
3574 error = RProperty::Delete(KMockLtsyFactoryProperty, EComplete ); |
|
3575 } |
|
3576 |
|
3577 void CCTsyTelephonyAudioControlFU::CheckNoCallRouting() |
|
3578 { |
|
3579 // check that there is no calls in call routing control |
|
3580 TInt callCount(0); |
|
3581 TInt error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount ); |
|
3582 ASSERT_EQUALS( KErrNone, error ); |
|
3583 |
|
3584 // there should not be any calls |
|
3585 ASSERT_EQUALS( 0, callCount ); |
|
3586 |
|
3587 // check that the call name is still undefined |
|
3588 TName callName; |
|
3589 error = RProperty::Get( KMockLtsyFactoryProperty, ECallName, callName ); |
|
3590 ASSERT_EQUALS( KErrNone, error ); |
|
3591 ASSERT_EQUALS( 0, callName.Compare( KNullDesC ) ); |
|
3592 } |
|
3593 |
|
3594 CCTsyTelephonyAudioControlFU::~CCTsyTelephonyAudioControlFU() |
|
3595 { |
|
3596 DeletePropeties(); |
|
3597 } |
|
3598 |
|
3599 void CCTsyTelephonyAudioControlFU::TestNotifyTelephonyAudioControlError0001L() |
|
3600 { |
|
3601 DefinePropeties( ETrue, EVersion2 ); |
|
3602 |
|
3603 OpenEtelServerL(EUseExtendedError); |
|
3604 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
3605 OpenPhoneL(); |
|
3606 |
|
3607 RBuf8 data; |
|
3608 CleanupClosePushL(data); |
|
3609 |
|
3610 RBuf8 expectData; |
|
3611 CleanupClosePushL(expectData); |
|
3612 |
|
3613 RBuf8 completeData; |
|
3614 CleanupClosePushL(completeData); |
|
3615 |
|
3616 TRequestStatus status( KErrNone ); |
|
3617 TInt callId( 1 ); |
|
3618 RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService ); |
|
3619 RMobileCall::TMobileCallParamsV7 callParams; |
|
3620 RMobileCall::TMobileCallInfoV8 callInfo; |
|
3621 callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
3622 callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
3623 callParams.iInterval = 100; |
|
3624 callParams.iWaitForDialTone = RCall::EDialToneWait; |
|
3625 callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
3626 callParams.iCug.iExplicitInvoke = EFalse; |
|
3627 callParams.iCug.iCugIndex = 0xFFFF; |
|
3628 callParams.iCug.iSuppressPrefCug = EFalse; |
|
3629 callParams.iCug.iSuppressOA = EFalse; |
|
3630 callParams.iAutoRedial = EFalse; |
|
3631 callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
3632 callInfo.iService = mobileService; |
|
3633 callInfo.iStatus = RMobileCall::EStatusUnknown; |
|
3634 callInfo.iCallId =-1; |
|
3635 callInfo.iExitCode =0; |
|
3636 callInfo.iEmergency =0; |
|
3637 callInfo.iForwarded =0; |
|
3638 callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
3639 callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
3640 callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
3641 callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
3642 callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
3643 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo); |
|
3644 TMockLtsyCallData0 mockData0(callId, mobileService); |
|
3645 |
|
3646 RCall::TCallParams callParamsX1; |
|
3647 TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1); |
|
3648 |
|
3649 TRequestStatus mockLtsyStatus( KErrNone ); |
|
3650 RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting ); |
|
3651 |
|
3652 TInt hangUpCause( KErrGsmReleaseByUser ); |
|
3653 TBool autoStChangeDisable ( EFalse ); |
|
3654 |
|
3655 TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable ); |
|
3656 |
|
3657 RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo ); |
|
3658 |
|
3659 RLine line; |
|
3660 RMobileCall call; |
|
3661 |
|
3662 //------------------------------------------------------------------------- |
|
3663 // TEST A: failure to dispatch request to LTSY |
|
3664 //------------------------------------------------------------------------- |
|
3665 |
|
3666 // DialL |
|
3667 |
|
3668 // error when call is in RMobileCall::EStatusDialling |
|
3669 |
|
3670 // reset the properties to ensure to get valid data |
|
3671 DefinePropeties( ETrue, EVersion2 ); |
|
3672 |
|
3673 // reset line & call |
|
3674 TInt error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
3675 CleanupClosePushL( line ); |
|
3676 ASSERT_EQUALS( KErrNone, error ); |
|
3677 |
|
3678 error = call.OpenNewCall( line ); |
|
3679 CleanupClosePushL( call ); |
|
3680 ASSERT_EQUALS( KErrNone, error ); |
|
3681 |
|
3682 // prepare MockLTSY |
|
3683 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
3684 mockData2.SerialiseL(expectData); |
|
3685 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
3686 mockData0.SerialiseL(completeData); |
|
3687 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
3688 |
|
3689 // make the call where SetupTelephonyAudio fails |
|
3690 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
3691 User::WaitForRequest( status ); |
|
3692 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3693 |
|
3694 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3695 ASSERT_EQUALS( KErrNone, error ); |
|
3696 |
|
3697 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported ); |
|
3698 ASSERT_EQUALS( KErrNone, error ); |
|
3699 |
|
3700 // change call status and check it is OK |
|
3701 UpdateCallStatusL( call, RMobileCall::EStatusDialling, EFalse, ETrue ); |
|
3702 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
3703 |
|
3704 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone ); |
|
3705 ASSERT_EQUALS( KErrNone, error ); |
|
3706 |
|
3707 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
3708 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
3709 |
|
3710 // cleanup |
|
3711 AssertMockLtsyStatusL(); |
|
3712 CleanupStack::PopAndDestroy( &call ); |
|
3713 CleanupStack::PopAndDestroy( &line ); |
|
3714 |
|
3715 // DialL |
|
3716 |
|
3717 // error when call is in RMobileCall::EStatusDialling |
|
3718 // in VoiceLine 2 |
|
3719 |
|
3720 // reset the properties to ensure to get valid data |
|
3721 DefinePropeties( ETrue, EVersion2 ); |
|
3722 |
|
3723 // reset line & call |
|
3724 error = line.Open( iPhone, KMmTsyVoice2LineName ); |
|
3725 CleanupClosePushL( line ); |
|
3726 ASSERT_EQUALS( KErrNone, error ); |
|
3727 |
|
3728 error = call.OpenNewCall( line ); |
|
3729 CleanupClosePushL( call ); |
|
3730 ASSERT_EQUALS( KErrNone, error ); |
|
3731 |
|
3732 RMobilePhone::TMobileService mobileService2( RMobilePhone::EAuxVoiceService ); |
|
3733 RMobileCall::TMobileCallParamsV7 callParams2; |
|
3734 RMobileCall::TMobileCallInfoV8 callInfo2; |
|
3735 callParams2.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; |
|
3736 callParams2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; |
|
3737 callParams2.iInterval = 100; |
|
3738 callParams2.iWaitForDialTone = RCall::EDialToneWait; |
|
3739 callParams2.iIdRestrict = RMobileCall::EIdRestrictDefault; |
|
3740 callParams2.iCug.iExplicitInvoke = EFalse; |
|
3741 callParams2.iCug.iCugIndex = 0xFFFF; |
|
3742 callParams2.iCug.iSuppressPrefCug = EFalse; |
|
3743 callParams2.iCug.iSuppressOA = EFalse; |
|
3744 callParams2.iAutoRedial = EFalse; |
|
3745 callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
3746 callInfo2.iService = mobileService2; |
|
3747 callInfo2.iStatus = RMobileCall::EStatusUnknown; |
|
3748 callInfo2.iCallId =-1; |
|
3749 callInfo2.iExitCode =0; |
|
3750 callInfo2.iEmergency =0; |
|
3751 callInfo2.iForwarded =0; |
|
3752 callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
3753 callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
3754 callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
3755 callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
3756 callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
3757 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService2, callParams2, callInfo2); |
|
3758 TMockLtsyCallData0 mockData4(callId, mobileService2); |
|
3759 |
|
3760 RCall::TCallParams callParamsX2; |
|
3761 TPckg<RCall::TCallParams> pckgCallParamsX2(callParamsX2); |
|
3762 |
|
3763 // prepare MockLTSY |
|
3764 CallGetMobileCallInfoL(callId, mobileService2, KPhoneNumber ); |
|
3765 mockData3.SerialiseL(expectData); |
|
3766 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
3767 mockData4.SerialiseL(completeData); |
|
3768 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
3769 |
|
3770 // make the call where SetupTelephonyAudio fails |
|
3771 call.Dial( status, pckgCallParamsX2, KPhoneNumber ); |
|
3772 User::WaitForRequest( status ); |
|
3773 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3774 |
|
3775 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3776 ASSERT_EQUALS( KErrNone, error ); |
|
3777 |
|
3778 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported ); |
|
3779 ASSERT_EQUALS( KErrNone, error ); |
|
3780 |
|
3781 // change call status and check it is OK |
|
3782 UpdateCallStatusL( call, RMobileCall::EStatusDialling, EFalse, ETrue ); |
|
3783 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
3784 |
|
3785 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone ); |
|
3786 ASSERT_EQUALS( KErrNone, error ); |
|
3787 |
|
3788 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
3789 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
3790 |
|
3791 // cleanup |
|
3792 AssertMockLtsyStatusL(); |
|
3793 CleanupStack::PopAndDestroy( &call ); |
|
3794 CleanupStack::PopAndDestroy( &line ); |
|
3795 |
|
3796 // error when call is in RMobileCall::EStatusConnecting |
|
3797 |
|
3798 // reset the properties to ensure to get valid data |
|
3799 DefinePropeties( ETrue, EVersion2 ); |
|
3800 |
|
3801 // reset line & call |
|
3802 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
3803 CleanupClosePushL( line ); |
|
3804 ASSERT_EQUALS( KErrNone, error ); |
|
3805 |
|
3806 error = call.OpenNewCall( line ); |
|
3807 CleanupClosePushL( call ); |
|
3808 ASSERT_EQUALS( KErrNone, error ); |
|
3809 |
|
3810 // prepare MockLTSY |
|
3811 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
3812 RMobileCall::TMobileCallInfoV8 callInfo3; |
|
3813 callInfo3.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; |
|
3814 callInfo3.iService = mobileService; |
|
3815 callInfo3.iStatus = RMobileCall::EStatusUnknown; |
|
3816 callInfo3.iCallId =-1; |
|
3817 callInfo3.iExitCode =0; |
|
3818 callInfo3.iEmergency =0; |
|
3819 callInfo3.iForwarded =0; |
|
3820 callInfo3.iPrivacy = RMobilePhone::EPrivacyUnspecified; |
|
3821 callInfo3.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; |
|
3822 callInfo3.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; |
|
3823 callInfo3.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; |
|
3824 callInfo3.iDialledParty.iTelNumber.Copy( KPhoneNumber ); |
|
3825 TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData5(0, mobileService, callParams, callInfo3); |
|
3826 mockData5.SerialiseL(expectData); |
|
3827 |
|
3828 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
3829 mockData0.SerialiseL(completeData); |
|
3830 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
3831 |
|
3832 // make the call where SetupTelephonyAudio fails |
|
3833 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
3834 User::WaitForRequest( status ); |
|
3835 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3836 |
|
3837 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3838 ASSERT_EQUALS( KErrNone, error ); |
|
3839 |
|
3840 // change call status and check it is OK |
|
3841 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
3842 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
3843 |
|
3844 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported ); |
|
3845 ASSERT_EQUALS( KErrNone, error ); |
|
3846 |
|
3847 // change call status and check it is OK |
|
3848 UpdateCallStatusL( call, RMobileCall::EStatusConnecting, EFalse, ETrue ); |
|
3849 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
3850 |
|
3851 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone ); |
|
3852 ASSERT_EQUALS( KErrNone, error ); |
|
3853 |
|
3854 UpdateCallStatusL( call, RMobileCall::EStatusIdle ); |
|
3855 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
3856 |
|
3857 // cleanup |
|
3858 AssertMockLtsyStatusL(); |
|
3859 CleanupStack::PopAndDestroy( &call ); |
|
3860 CleanupStack::PopAndDestroy( &line ); |
|
3861 |
|
3862 // error when call is in RMobileCall::EStatusConnected |
|
3863 |
|
3864 // reset the properties to ensure to get valid data |
|
3865 DefinePropeties( ETrue, EVersion2 ); |
|
3866 |
|
3867 // reset line & call |
|
3868 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
3869 CleanupClosePushL( line ); |
|
3870 ASSERT_EQUALS( KErrNone, error ); |
|
3871 |
|
3872 error = call.OpenNewCall( line ); |
|
3873 CleanupClosePushL( call ); |
|
3874 ASSERT_EQUALS( KErrNone, error ); |
|
3875 |
|
3876 // prepare MockLTSY |
|
3877 CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); |
|
3878 mockData5.SerialiseL(expectData); |
|
3879 iMockLTSY.ExpectL(EEtelCallDial, expectData); |
|
3880 mockData0.SerialiseL(completeData); |
|
3881 iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); |
|
3882 |
|
3883 // make the call where SetupTelephonyAudio fails |
|
3884 call.Dial( status, pckgCallParamsX1, KPhoneNumber ); |
|
3885 User::WaitForRequest( status ); |
|
3886 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3887 |
|
3888 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3889 ASSERT_EQUALS( KErrNone, error ); |
|
3890 |
|
3891 // change call status and check it is OK |
|
3892 UpdateCallStatusL( call, RMobileCall::EStatusDialling ); |
|
3893 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling ); |
|
3894 |
|
3895 // change call status and check it is OK |
|
3896 UpdateCallStatusL( call, RMobileCall::EStatusConnecting, EFalse, EFalse ); |
|
3897 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting ); |
|
3898 |
|
3899 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported ); |
|
3900 ASSERT_EQUALS( KErrNone, error ); |
|
3901 |
|
3902 // change call status and check it is OK |
|
3903 UpdateCallStatusL( call, RMobileCall::EStatusConnected, EFalse, ETrue ); |
|
3904 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected ); |
|
3905 |
|
3906 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone ); |
|
3907 ASSERT_EQUALS( KErrNone, error ); |
|
3908 |
|
3909 UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue, EFalse ); |
|
3910 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
3911 |
|
3912 // cleanup |
|
3913 AssertMockLtsyStatusL(); |
|
3914 CleanupStack::PopAndDestroy( &call ); |
|
3915 CleanupStack::PopAndDestroy( &line ); |
|
3916 |
|
3917 // error when call is in RMobileCall::EStatusAnswering |
|
3918 |
|
3919 // reset the properties to ensure to get valid data |
|
3920 DefinePropeties( ETrue, EVersion2 ); |
|
3921 |
|
3922 // reset line |
|
3923 error = line.Open( iPhone, KMmTsyVoice1LineName ); |
|
3924 CleanupClosePushL( line ); |
|
3925 ASSERT_EQUALS( KErrNone, error ); |
|
3926 |
|
3927 TName incomingCallName; |
|
3928 TRequestStatus requestNotify( KErrNone ); |
|
3929 line.NotifyIncomingCall( status, incomingCallName); |
|
3930 |
|
3931 TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo ); |
|
3932 mockCallData.SerialiseL( completeData ); |
|
3933 |
|
3934 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
3935 iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ; |
|
3936 User::WaitForRequest( mockLtsyStatus ); |
|
3937 |
|
3938 AssertMockLtsyStatusL(); |
|
3939 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
3940 |
|
3941 User::WaitForRequest( requestNotify ); |
|
3942 AssertMockLtsyStatusL(); |
|
3943 ASSERT_EQUALS( KErrNone, requestNotify.Int() ); |
|
3944 |
|
3945 mobileCallStatus = RMobileCall::EStatusRinging; |
|
3946 TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus ); |
|
3947 completeData.Close(); |
|
3948 mockCallData2.SerialiseL(completeData); |
|
3949 |
|
3950 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
3951 iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); |
|
3952 User::WaitForRequest(mockLtsyStatus); |
|
3953 AssertMockLtsyStatusL(); |
|
3954 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
3955 |
|
3956 expectData.Close(); |
|
3957 mockData0.SerialiseL( expectData ); |
|
3958 iMockLTSY.ExpectL( EEtelCallAnswer, expectData ); |
|
3959 iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData ); |
|
3960 |
|
3961 // reset the call |
|
3962 error = call.OpenExistingCall( line, incomingCallName ); |
|
3963 CleanupClosePushL( call ); |
|
3964 ASSERT_EQUALS( KErrNone, error ); |
|
3965 |
|
3966 // answer the call |
|
3967 call.AnswerIncomingCall( status, pckgCallParamsX1 ); |
|
3968 User::WaitForRequest( status ); |
|
3969 ASSERT_EQUALS( KErrNone, status.Int() ); |
|
3970 |
|
3971 error = call.GetMobileCallInfo( callInfoPckg ); |
|
3972 ASSERT_EQUALS( KErrNone, error ); |
|
3973 |
|
3974 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported ); |
|
3975 ASSERT_EQUALS( KErrNone, error ); |
|
3976 |
|
3977 // change call status and check it is OK |
|
3978 UpdateCallStatusL( call, RMobileCall::EStatusAnswering, EFalse, ETrue ); |
|
3979 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering ); |
|
3980 |
|
3981 error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone ); |
|
3982 ASSERT_EQUALS( KErrNone, error ); |
|
3983 |
|
3984 UpdateCallStatusL( call, RMobileCall::EStatusIdle, EFalse, EFalse ); |
|
3985 CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle ); |
|
3986 |
|
3987 CleanupStack::PopAndDestroy( &call ); |
|
3988 CleanupStack::PopAndDestroy( &line ); |
|
3989 AssertMockLtsyStatusL(); |
|
3990 |
|
3991 // cleanup |
|
3992 CleanupStack::PopAndDestroy( &completeData ); |
|
3993 CleanupStack::PopAndDestroy( &expectData ); |
|
3994 CleanupStack::PopAndDestroy( &data ); |
|
3995 CleanupStack::PopAndDestroy( this ); |
|
3996 } |
|
3997 |
|
3998 // End of File |