116     ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateActiveCalls0001L);

   117     ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateActiveCalls0001bL);

   118     ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateActiveCalls0001cL);

   119     ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateActiveCalls0002L);

   120     ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateActiveCalls0004L);

   121     ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateActiveCalls0005L);  

 10111 /**

 10112 @SYMTestCaseID BA-CTSY-CCON-MTACTC-0001

 10113 @SYMComponent  telephony_ctsy

 10114 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::TerminateActiveCalls  When the call status is EStatusHold

 10115 @SYMTestPriority High

 10116 @SYMTestActions Invokes RMobilePhone::TerminateActiveCalls

 10117 @SYMTestExpectedResults Pass

 10118 @SYMTestType CT

 10119 */

 10120 void CCTsyCallControlFU::TestTerminateActiveCalls0001L()

 10121     {

 10122     OpenEtelServerL(EUseExtendedError);

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

 10124     OpenPhoneL();

 10125 

 10126     RBuf8 expectData;

 10127     CleanupClosePushL(expectData); // PUSH

 10128     

 10129     TRequestStatus requestStatus;

 10130     

 10131     //-----------------------------------------------------------------------

 10132     // TEST 0: with no active calls 

 10133     //----------------------------------------------------------------------

 10134     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq,KErrNone);

 10135     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrNone);

 10136     iPhone.TerminateActiveCalls(requestStatus);

 10137     User::WaitForRequest(requestStatus);

 10138     ASSERT_EQUALS(KErrNone, requestStatus.Int());

 10139     AssertMockLtsyStatusL();

 10140     

 10141     //-------------------------------------------------------------------------

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

 10143     //-------------------------------------------------------------------------

 10144 

 10145     // open new line and call for KMmTsyVoice1LineName

 10146     RLine line;

 10147     RCall call;

 10148     TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH

 10149     ASSERT_EQUALS(KErrNone, errorCode);

 10150 

 10151     // create new incoming call

 10152     TName incomingCallName;

 10153     TInt callId = 1;

 10154     errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

 10155             RMobilePhone::EVoiceService, RMobileCall::EStatusHold);   

 10156     

 10157     ASSERT_EQUALS(KErrNone, errorCode);

 10158         

 10159     CleanupClosePushL(call); // PUSH

 10160     errorCode = call.OpenExistingCall(line, incomingCallName);

 10161     ASSERT_EQUALS(KErrNone, errorCode);

 10162     //-------------------------------------------------------------------------

 10163 

 10164     TMockLtsyData1<TInt> mockData(callId);

 10165     mockData.SerialiseL(expectData);

 10166     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq, expectData, KErrNotSupported);

 10167     iPhone.TerminateActiveCalls(requestStatus);

 10168 

 10169     User::WaitForRequest(requestStatus);

 10170     ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

 10171     AssertMockLtsyStatusL();

 10172 

 10173     

 10174     

 10175     //-------------------------------------------------------------------------

 10176     // TEST B: failure on completion of pending request from LTSY->CTSY

 10177     //-------------------------------------------------------------------------

 10178     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq, expectData);

 10179     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrGeneral);

 10180 

 10181     iPhone.TerminateActiveCalls(requestStatus);

 10182 

 10183     User::WaitForRequest(requestStatus);

 10184     ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

 10185     AssertMockLtsyStatusL();

 10186     

 10187     //-------------------------------------------------------------------------

 10188     // TEST C: Successful completion request of

 10189     // RMobilePhone::TerminateActiveCalls.

 10190     //-------------------------------------------------------------------------

 10191     

 10192     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq, expectData);

 10193     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrNone);

 10194     

 10195     iPhone.TerminateActiveCalls(requestStatus);

 10196     User::WaitForRequest(requestStatus);

 10197     ASSERT_EQUALS(KErrNone, requestStatus.Int());

 10198     AssertMockLtsyStatusL();

 10199     

 10200     //-------------------------------------------------------------------------

 10201     // TEST E: Unsolicited completion of RMobilePhone::TerminateActiveCalls

 10202     // from LTSY.

 10203     //-------------------------------------------------------------------------

 10204 

 10205     TRequestStatus mockLtsyStatus;

 10206     iMockLTSY.NotifyTerminated(mockLtsyStatus);

 10207     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrNone);

 10208     User::WaitForRequest(mockLtsyStatus);

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

 10210     AssertMockLtsyStatusL();

 10211         

 10212     CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this

 10213     }

 10214 

 10215 

 10216 /**

 10217 @SYMTestCaseID BA-CTSY-CCON-MTACTC-000B1

 10218 @SYMComponent  telephony_ctsy

 10219 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::TerminateActiveCalls When the call status is EStatusRinging

 10220 @SYMTestPriority High

 10221 @SYMTestActions Invokes RMobilePhone::TerminateActiveCalls

 10222 @SYMTestExpectedResults Pass

 10223 @SYMTestType CT

 10224 */

 10225 void CCTsyCallControlFU::TestTerminateActiveCalls0001bL()

 10226     {

 10227     OpenEtelServerL(EUseExtendedError);

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

 10229     OpenPhoneL();

 10230 

 10231     RBuf8 expectData;

 10232     CleanupClosePushL(expectData); // PUSH

 10233         

 10234     TRequestStatus requestStatus;

 10235     // open new line and call for KMmTsyVoice1LineName

 10236     RLine line;

 10237     RCall call;

 10238     TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH

 10239     ASSERT_EQUALS(KErrNone, errorCode);

 10240 

 10241     // create new incoming call

 10242     TName incomingCallName;

 10243     TInt callId = 1;

 10244     errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

 10245     RMobilePhone::EVoiceService, RMobileCall::EStatusRinging);   

 10246         

 10247     ASSERT_EQUALS(KErrNone, errorCode);

 10248     CleanupClosePushL(call); // PUSH

 10249     errorCode = call.OpenExistingCall(line, incomingCallName);

 10250     ASSERT_EQUALS(KErrNone, errorCode);

 10251     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq,KErrNone);

 10252     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrNone);

 10253     iPhone.TerminateActiveCalls(requestStatus);

 10254     User::WaitForRequest(requestStatus);

 10255     ASSERT_EQUALS(KErrNone, requestStatus.Int());

 10256     AssertMockLtsyStatusL();

 10257         

 10258     CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this

 10259     }

 10260     

 10261 /**

 10262 @SYMTestCaseID BA-CTSY-CCON-MTACTC-000C1

 10263 @SYMComponent  telephony_ctsy

 10264 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::TerminateActiveCalls When the call status is EStatusConnecting

 10265 @SYMTestPriority High

 10266 @SYMTestActions Invokes RMobilePhone::TerminateActiveCalls

 10267 @SYMTestExpectedResults Pass

 10268 @SYMTestType CT

 10269 */

 10270 void CCTsyCallControlFU::TestTerminateActiveCalls0001cL()

 10271     {

 10272     OpenEtelServerL(EUseExtendedError);

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

 10274     OpenPhoneL();

 10275 

 10276     RBuf8 expectData;

 10277     CleanupClosePushL(expectData); // PUSH

 10278         

 10279     TRequestStatus requestStatus;

 10280     // open new line and call for KMmTsyVoice1LineName

 10281     RLine line;    

 10282     TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH

 10283     ASSERT_EQUALS(KErrNone, errorCode);

 10284 

 10285     // create new incoming call

 10286     TName incomingCallName;

 10287     TInt callId = 1;

 10288     errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

 10289                 RMobilePhone::EVoiceService, RMobileCall::EStatusConnecting);   

 10290         

 10291     ASSERT_EQUALS(KErrNone, errorCode);

 10292     RCall call;    

 10293     CleanupClosePushL(call); // PUSH

 10294     errorCode = call.OpenExistingCall(line, incomingCallName);

 10295     ASSERT_EQUALS(KErrNone, errorCode);

 10296     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq,KErrNone);

 10297     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrNone);

 10298     iPhone.TerminateActiveCalls(requestStatus);

 10299     User::WaitForRequest(requestStatus);

 10300     ASSERT_EQUALS(KErrNone, requestStatus.Int());

 10301     AssertMockLtsyStatusL();

 10302         

 10303     CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this

 10304     }

 10305 

 10306 

 10307 

 10308 /**

 10309 @SYMTestCaseID BA-CTSY-CCON-MTACTC-0002

 10310 @SYMComponent  telephony_ctsy

 10311 @SYMTestCaseDesc Test support in CTSY for cancelling RMobilePhone::TerminateActiveCalls

 10312 @SYMTestPriority High

 10313 @SYMTestActions Invokes RMobilePhone::TerminateActiveCalls and cancels it

 10314 @SYMTestExpectedResults Pass

 10315 @SYMTestType CT

 10316 */

 10317 void CCTsyCallControlFU::TestTerminateActiveCalls0002L()

 10318     {

 10319     OpenEtelServerL(EUseExtendedError);

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

 10321     OpenPhoneL();

 10322     

 10323     RBuf8 expectData;

 10324     CleanupClosePushL(expectData); // PUSH

 10325     

 10326     //-------------------------------------------------------------------------

 10327     

 10328     // open new line and call for KMmTsyVoice1LineName

 10329     RLine line;

 10330     RCall call;

 10331     TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH

 10332     ASSERT_EQUALS(KErrNone, errorCode);

 10333 

 10334     // create new incoming call

 10335     TName incomingCallName;

 10336     TInt callId = 1;

 10337     errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

 10338             RMobilePhone::EVoiceService, RMobileCall::EStatusHold);   

 10339     

 10340     ASSERT_EQUALS(KErrNone, errorCode);

 10341         

 10342     CleanupClosePushL(call); // PUSH

 10343     errorCode = call.OpenExistingCall(line, incomingCallName);

 10344     ASSERT_EQUALS(KErrNone, errorCode);

 10345     //-------------------------------------------------------------------------

 10346     

 10347     //-------------------------------------------------------------------------

 10348     // Test A: cancelling of RMobilePhone::TerminateActiveCalls

 10349     //-------------------------------------------------------------------------

 10350 

 10351     TMockLtsyData1<TInt> mockData(callId);

 10352     mockData.SerialiseL(expectData);

 10353     

 10354     TRequestStatus mockLtsyStatus;

 10355     iMockLTSY.NotifyTerminated(mockLtsyStatus);

 10356         

 10357     // Expect call down to LTSY for this IPC

 10358     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq, expectData);

 10359 

 10360     // Queue response to be delayed to give time for cancel to come through

 10361     // There is no interface for cancelling the simple TerminateActiveCalls request once passed to LTSY, 

 10362     // however this test will still emulate the completion of the request which will finally return from LTSY regardless.

 10363     

 10364     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrNone, 10);

 10365 

 10366     TRequestStatus requestStatus;

 10367     iPhone.TerminateActiveCalls(requestStatus);

 10368     iPhone.CancelAsyncRequest(EMobilePhoneTerminateActiveCalls);

 10369     User::WaitForRequest(requestStatus);

 10370     INFO_PRINTF2(_L("requestStatus.Int() %d"),(requestStatus.Int()));

 10371     ASSERT_EQUALS(KErrNone, requestStatus.Int());

 10372     

 10373     AssertMockLtsyStatusL();

 10374     

 10375     User::WaitForRequest(mockLtsyStatus);

 10376     INFO_PRINTF2(_L("mockLtsyStatus.Int() %d"),(mockLtsyStatus.Int()));

 10377     

 10378     AssertMockLtsyStatusL();

 10379     

 10380     CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this

 10381     }

 10382 

 10383 /**

 10384 @SYMTestCaseID BA-CTSY-CCON-MTACTC-0004

 10385 @SYMComponent  telephony_ctsy

 10386 @SYMTestCaseDesc Test support in CTSY for multiple client requests of RMobilePhone::TerminateActiveCalls

 10387 @SYMTestPriority High

 10388 @SYMTestActions Invokes RMobilePhone::TerminateActiveCalls on multiple clients

 10389 @SYMTestExpectedResults Pass

 10390 @SYMTestType CT

 10391 */

 10392 void CCTsyCallControlFU::TestTerminateActiveCalls0004L()

 10393     {

 10394 

 10395     OpenEtelServerL(EUseExtendedError);

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

 10397     OpenPhoneL();

 10398         

 10399     // Open second client

 10400     RTelServer telServer2;

 10401     TInt ret = telServer2.Connect();

 10402     ASSERT_EQUALS(KErrNone, ret);

 10403     CleanupClosePushL(telServer2);

 10404 

 10405     RMobilePhone phone2;

 10406     ret = phone2.Open(iTelServer,KMmTsyPhoneName);

 10407     ASSERT_EQUALS(KErrNone, ret);

 10408     CleanupClosePushL(phone2);

 10409 

 10410     //

 10411     // set up line and call for first client

 10412     

 10413     RLine line;

 10414     RCall call;

 10415     TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH

 10416     ASSERT_EQUALS(KErrNone, errorCode);

 10417 

 10418     // create new incoming call

 10419     TName incomingCallName;

 10420     TInt callId = 1;

 10421     errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

 10422             RMobilePhone::EVoiceService, RMobileCall::EStatusHold);   

 10423     

 10424     ASSERT_EQUALS(KErrNone, errorCode);

 10425         

 10426     CleanupClosePushL(call); // PUSH

 10427     errorCode = call.OpenExistingCall(line, incomingCallName);

 10428     ASSERT_EQUALS(KErrNone, errorCode);

 10429     

 10430     //

 10431     // set up call for second client

 10432     

 10433     RLine line2;

 10434     RCall call2;

 10435     errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); // PUSH

 10436     ASSERT_EQUALS(KErrNone, errorCode);

 10437 

 10438     // create new incoming call

 10439     TName incomingCallName2;

 10440     TInt callId2 = 2;

 10441     errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, 

 10442             RMobilePhone::EVoiceService, RMobileCall::EStatusHold);   

 10443     

 10444     ASSERT_EQUALS(KErrNone, errorCode);

 10445         

 10446     CleanupClosePushL(call2); // PUSH

 10447     errorCode = call2.OpenExistingCall(line2, incomingCallName2);

 10448     ASSERT_EQUALS(KErrNone, errorCode);

 10449     

 10450     // let's start testing...

 10451     

 10452     RBuf8 expectData;

 10453     CleanupClosePushL(expectData); // PUSH

 10454     TMockLtsyData1<TInt> mockData(callId);

 10455     mockData.SerialiseL(expectData);

 10456     

 10457     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq, expectData);

 10458     iMockLTSY.CompleteL(ECtsyPhoneTerminateActiveCallsComp, KErrNone, 20);

 10459     TRequestStatus requestStatus;

 10460     TRequestStatus requestStatus2;

 10461     iPhone.TerminateActiveCalls(requestStatus);

 10462     phone2.TerminateActiveCalls(requestStatus2);

 10463     

 10464     User::WaitForRequest(requestStatus);

 10465     ASSERT_EQUALS(KErrNone, requestStatus.Int());

 10466     

 10467     User::WaitForRequest(requestStatus2);

 10468     ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());

 10469     

 10470     AssertMockLtsyStatusL();

 10471     

 10472     CleanupStack::PopAndDestroy(8, this);   // expectData,

 10473                                             // call2, line2, call, line,

 10474                                             // phone2, telServer2, this

 10475     }

 10476 

 10477 /**

 10478 @SYMTestCaseID BA-CTSY-CCON-MTACTC-0005

 10479 @SYMComponent  telephony_ctsy

 10480 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::TerminateActiveCalls with timeout.

 10481 @SYMTestPriority High

 10482 @SYMTestActions Invokes RMobilePhone::TerminateActiveCalls and tests for timeout.

 10483 @SYMTestExpectedResults Pass

 10484 @SYMTestType CT

 10485 */

 10486 void CCTsyCallControlFU::TestTerminateActiveCalls0005L()

 10487     {

 10488     OpenEtelServerL(EUseExtendedError);

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

 10490     OpenPhoneL();

 10491 

 10492     RBuf8 expectData;

 10493     CleanupClosePushL(expectData); // PUSH

 10494    

 10495     

 10496     // open new line and call for KMmTsyVoice1LineName

 10497     RLine line;

 10498     RCall call;

 10499     TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH

 10500     ASSERT_EQUALS(KErrNone, errorCode);

 10501 

 10502     

 10503     // create new incoming call

 10504     TName incomingCallName;

 10505     TInt callId = 1;

 10506     errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

 10507             RMobilePhone::EVoiceService, RMobileCall::EStatusHold);   

 10508     

 10509     ASSERT_EQUALS(KErrNone, errorCode);

 10510         

 10511     CleanupClosePushL(call); // PUSH

 10512     errorCode = call.OpenExistingCall(line, incomingCallName);

 10513     ASSERT_EQUALS(KErrNone, errorCode);

 10514     //-------------------------------------------------------------------------

 10515 

 10516     TMockLtsyData1<TInt> mockData(callId);

 10517     mockData.SerialiseL(expectData);    

 10518     //-------------------------------------------------------------------------

 10519     // Test A: Test timeout of RMobilePhone::TerminateActiveCalls

 10520     //-------------------------------------------------------------------------

 10521     

 10522     TRequestStatus requestStatus;

 10523     iMockLTSY.ExpectL(ECtsyPhoneTerminateActiveCallsReq, expectData);

 10524     iPhone.TerminateActiveCalls(requestStatus);

 10525     User::WaitForRequest(requestStatus);

 10526     AssertMockLtsyStatusL();

 10527     ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());

 10528 

 10529     CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this

 10530     }