diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/test/component/src/cctsycallcontrolfu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/test/component/src/cctsycallcontrolfu.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,12391 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// The TEFUnit test suite for CallControl in the Common TSY. +// +// + +/** + @file +*/ + +#include "cctsycallcontrolfu.h" +#include +#include +#include +#include +#include +#include "tmockltsydata.h" +#include +#include +#include "MmTsy_timeoutdefs.h" + +CTestSuite* CCTsyCallControlFU::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0007L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0008L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0009L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall00010L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0001bL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0003L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006bL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006cL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006dL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006eL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006fL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006gL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006hL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006iL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0007L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0008L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0009L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0009bL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0009cL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial00010L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0007L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0009L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00010L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00011bL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00011cL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00012L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00014L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00015L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0001aL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDeflect0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDeflect0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDeflect0003L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0009L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSetIncomingCallType0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialISV0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialISV0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialISV00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialCallControl0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialCallControl0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialCallControl00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestEnumerateCall0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestEnumerateCall0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestEnumerateCall00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestNotifyHookChange0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestNotifyHookChange0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestNotifyHookChange00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestCompleteNotifyStatusChange0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUpdateLifeTime0001L); + + END_SUITE; + } + + +// +// Actual test cases +// + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::AnswerIncomingCall for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::AnswerIncomingCall for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus requestNotify; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData, KErrNotSupported); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrGeneral, expectData); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RCall::AnswerIncomingCall when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::AnswerIncomingCall + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : Call AnswerIncomingCall with null description + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + + TPtr8 null(NULL,0); + call.AnswerIncomingCall(requestStatus, null); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::AnswerIncomingCall coverage + // covers "if ( 0 < answerCallHandle )" condition + //------------------------------------------------------------------------- + + RCall call2; + CleanupClosePushL(call2); + TRequestStatus requestStatus2; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + call2.AnswerIncomingCall(requestStatus2, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call.Close(); + + CloseIncomingCallL(call2, callId, mobileService); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::AnswerIncomingCall coverage + // covers "else if( activeCall && + // ( !( KETelExt3rdPartyV1 == activeCall->GetExtensionId() ) && + // ( KETelExt3rdPartyV1 == extensionId ) ) )" condition + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusRinging; + + // create new incoming call1 + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + RMobileCall call1; + CleanupClosePushL(call1); + errorCode = call1.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + + TName incomingCallName2; + TInt callId2 = 2; + mobileCallStatus = RMobileCall::EStatusConnected; + + // create new incoming call2 + errorCode = CreateIncomingCallL(line, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + call2.AnswerIncomingCall(requestStatus2, mmParamsPckgV1); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams; + TPckg callParamsPckg(callParams); + call1.AnswerIncomingCallISV(requestStatus, callParamsPckg); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGsmNotAllowed, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + ASSERT_EQUALS(KErrNotSupported, requestStatus2.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(7, this); // expectData, completeData, call, line, call2 + // this, call1 + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::AnswerIncomingCall for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RCall::AnswerIncomingCall for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test cancelling of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrCancel, expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.CancelAsyncRequest(EEtelCallAnswer); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrCancel, requestStatus.Int()); + + User::WaitForRequest(mockLtsyStatus); + + CleanupStack::PopAndDestroy(4); // this, expectData, call, line + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::AnswerIncomingCall for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::AnswerIncomingCall for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RCall call1; + CleanupClosePushL(call1); + + RCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TName incomingCallName1; + + TInt callId2 = 2; + TName incomingCallName2; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData01(callId1, mobileService); + + expectData.Close(); + mockData01.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + call1.AnswerIncomingCall(requestStatus1, mmParamsPckgV1); + + TMockLtsyCallData0 mockData02(callId2, mobileService); + expectData.Close(); + mockData02.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + call2.AnswerIncomingCall(requestStatus2, mmParamsPckgV1); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + // close incoming call1 + CloseIncomingCallL(call1, callId1, mobileService); + AssertMockLtsyStatusL(); + + // close incoming call2 + CloseIncomingCallL(call2, callId2, mobileService); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // Test for increase coverage + //------------------------------------------------------------------------- + + line1.NotifyIncomingCall(requestStatus1, incomingCallName1); + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + mobileCallStatus = RMobileCall::EStatusConnected; + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusHold; + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + call1.AnswerIncomingCall(requestStatus1, mmParamsPckgV1); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGsmNotAllowed, requestStatus1.Int()); + + //------------------------------------------------------------------------- + + // Done ! + CleanupStack::PopAndDestroy(4); // line1, line2, call1, call2 + CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, expectData, this, completeData + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::AnswerIncomingCall with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::AnswerIncomingCall and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::AnswerIncomingCall for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::AnswerIncomingCall for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0006L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData, KErrNotSupported); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrGeneral, expectData); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RCall::AnswerIncomingCall when result is not cached. + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::AnswerIncomingCall + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : to increase CMmDataCallTsy::AnswerIncomingCall coverage + // covers "if ( 0 < iAnswerCallHandle )" condition + //------------------------------------------------------------------------- + + RCall call2; + CleanupClosePushL(call2); + TRequestStatus requestStatus2; + + //------------------------------------------------------------------------- + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + RMobileCall::TMobileCallParamsV1 callParamsV2; + TPckg mmParamsPckgV2(callParamsV2); + call2.AnswerIncomingCall(requestStatus2, mmParamsPckgV2); + + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + //------------------------------------------------------------------------- + // TEST : to increase CMmDataCallTsy::AnswerIncomingCall coverage + // covers "if ( iCallCaps.iFlags & RCall::KCapsAnswer || + // RCall::EStatusIdle == iCallStatus )" condition + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // call CMmDataCallTsy::CompleteNotifyStatusChange for set + // iCallCaps.iFlags &= ~( RCall::KCapsAnswer ); + + mobileCallStatus = RMobileCall::EStatusIdle; + + TMockLtsyCallData1 mockCallData2(callId, mobileService, mobileCallStatus); + mockCallData2.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // call CMmVoiceLineTsy::CompleteNotifyIncomingCall for set iCallId = 1. + RMobileCall::TMobileCallInfoV1 mobileCallInfo; + TMockLtsyCallData1 mockCallData1(callId, mobileService, mobileCallInfo); + completeData.Close(); + mockCallData1.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + //------------------------------------------------------------------------- + + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + CleanupStack::PopAndDestroy(2); // call2, line + + CloseIncomingCallL(call, callId, mobileService); + CleanupStack::PopAndDestroy(3); // expectData, call, completeData + + CleanupStack::PopAndDestroy(1, this); + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::AnswerIncomingCall for data calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RCall::AnswerIncomingCall for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0007L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // Test cancelling of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrCancel, expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.CancelAsyncRequest(EEtelCallAnswer); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrCancel, requestStatus.Int()); + + User::WaitForRequest(mockLtsyStatus); + + CleanupStack::PopAndDestroy(4); // this, expectData, call, line + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::AnswerIncomingCall with bad parameter data for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::AnswerIncomingCall with bad parameter data for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0008L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RCall call; + CleanupClosePushL(call); + + // open new line for KMmTsyVoice1LineName + RLine line; + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // Test B: Test passing wrong descriptor size to parameter in + // RCall::Dial + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + + TPtr8 null(NULL,0); + call.AnswerIncomingCall(requestStatus, null); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::AnswerIncomingCall for data calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::AnswerIncomingCall for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall0009L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RCall call1; + CleanupClosePushL(call1); + + RCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TName incomingCallName1; + + TInt callId2 = 2; + TName incomingCallName2; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData01(callId1, mobileService); + + expectData.Close(); + mockData01.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call1.AnswerIncomingCall(requestStatus1, mmParamsPckgV1); + + TMockLtsyCallData0 mockData02(callId2, mobileService); + expectData.Close(); + mockData02.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV2; + TPckg mmParamsPckgV2(callParamsV2); + call2.AnswerIncomingCall(requestStatus2, mmParamsPckgV2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + // Done ! + CleanupStack::PopAndDestroy(4); // line1, line2, call1, call2 + CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, expectData, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-00010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::AnswerIncomingCall with timeout for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::AnswerIncomingCall and tests for timeout for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall00010L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : Call AnswerIncomingCall with null description + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData); + + TPtr8 null(NULL,0); + call.AnswerIncomingCall(requestStatus, null); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAIC-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::AnswerIncomingCall for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::AnswerIncomingCall for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCall00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyFaxLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + + expectData.Close(); + mockData0.SerialiseL(expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, call, line + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus requestStatus2; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + RCall::TCallParams callParamsX; + TPckg pckgCallParamsX(callParamsX); + callParamsX.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX.iInterval = 100; + callParamsX.iWaitForDialTone = RCall::EDialToneWait; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + // Checking that we can return a specific error - KErrGsmCSConnectionBarred + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGsmCSConnectionBarred, completeData); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGsmCSConnectionBarred, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RCall::Dial when result is not cached. + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::Dial + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : to check that RCall::Dial works fine with RMobileCall::TMobileCallParamsV1 + //------------------------------------------------------------------------- + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + RMobileCall::TMobileCallParamsV1Pckg callParamsV1Pkg(callParamsV1); + callParamsV1.iCug.iCugIndex = 0xFFFF; + callParamsV1.iSpeakerControl = RCall::EMonitorSpeakerControlOnExceptDuringDialling; + callParamsV1.iSpeakerVolume = RCall::EMonitorSpeakerVolumeOff; + callParamsV1.iInterval = 100; + callParamsV1.iWaitForDialTone = RCall::EDialToneNoWait; + + TMockLtsyCallData2 + mockDataV1(0, mobileService, callParamsV1, callInfo); + + expectData.Close(); + mockDataV1.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call.Dial(requestStatus, callParamsV1Pkg, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + RMobileCall::TMobileCallParamsV1 checkParams; + RMobileCall::TMobileCallParamsV1Pckg checkParamsPkg(checkParams); + call.GetCallParams(checkParamsPkg); + + TInt compareResult = ((checkParams.iSpeakerControl != callParamsV1.iSpeakerControl) || + (checkParams.iSpeakerVolume != callParamsV1.iSpeakerVolume) || + (checkParams.iInterval != callParamsV1.iInterval) || + (checkParams.iWaitForDialTone != callParamsV1.iWaitForDialTone) || + (checkParams.iCug.iCugIndex != callParamsV1.iCug.iCugIndex)); + + if(KErrNone != compareResult) + { + ERR_PRINTF1(_L("RCall::GetCallParams did not return the same params as that used for Dial")); + ASSERT_EQUALS(KErrNone, compareResult); + } + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to check that RCall::Dial works fine with RMobileCall::TMobileCallParamsV2 + //------------------------------------------------------------------------- + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallParamsV2 callParamsV2; + RMobileCall::TMobileCallParamsV2Pckg callParamsV2Pkg(callParamsV2); + callParamsV2.iBearerMode = RMobileCall::EMulticallNewBearer; + + TMockLtsyCallData2 + mockDataV2(0, mobileService, callParamsV2, callInfo); + + expectData.Close(); + mockDataV2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call.Dial(requestStatus, callParamsV2Pkg, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + RMobileCall::TMobileCallParamsV2 checkParamsV2; + RMobileCall::TMobileCallParamsV2Pckg checkParamsV2Pkg(checkParamsV2); + call.GetCallParams(checkParamsV2Pkg); + + if(KErrNone != compareResult) + { + ERR_PRINTF1(_L("RCall::GetCallParams did not return the same V2 params as that used for Dial")); + ASSERT_EQUALS(KErrNone, compareResult); + } + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "else if ( RMobileCall::EStatusIdle != iMobileCallStatus )" condition + //------------------------------------------------------------------------- + + TName incomingCallName; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + CloseIncomingCallL(call, callId, mobileService); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "else if ( ( activeCall ) && ( KETelExt3rdPartyV1 == extensionId ) && + // ( KETelExt3rdPartyV1 != activeCall->GetExtensionId() ) )" condition + //------------------------------------------------------------------------- + + RMobileCall mobileCall; + mobileCallStatus = RMobileCall::EStatusConnected; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(mobileCall); + errorCode = mobileCall.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParamsXX; + TPckg pckgCallParamsXX(callParamsXX); + mobileCall.DialISV(requestStatus, pckgCallParamsXX, KPhoneNumber); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + mobileCall.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "else" condition in case of + // impossible of conditions "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )", + // "else if ( RMobileCall::EStatusIdle != iMobileCallStatus )", + // "else if ( ( 0 < dialHandle ) || ( ( KETelExt3rdPartyV1 == extensionId ) + // && ( 0 < dialHandleISV ) && !i3rdPartyEmergencyNumberCheckDone ) )", + // "else if ( ( activeCall ) && ( KETelExt3rdPartyV1 == extensionId ) + // && ( KETelExt3rdPartyV1 != activeCall->GetExtensionId() ) )" and + // "else if( extensionId == KETelExt3rdPartyV1 && + // !i3rdPartyEmergencyNumberCheckDone )". + //------------------------------------------------------------------------- + + RCall call2; + mobileCallStatus = RMobileCall::EStatusConnected; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + call2.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )" condition + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TRfStateInfo rfInfo = ERfsStateInfoInactive; + TMockLtsyData1 mockData1(rfInfo); + + expectData.Close(); + mockData1.SerialiseL(expectData); + + iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGsmOfflineOpNotAllowed, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0001b +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for voice calls with minimal parameters (RCall::TCallParams) +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0001bL() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + TInt errorCode = KErrNone; + + //-- For Voice1 ------------------------- + + TBuf<256> lineName(KMmTsyVoice1LineName); + // Open new line + RLine line; + errorCode = line.Open(iPhone, lineName); + ASSERT_EQUALS(KErrNone, errorCode); + CleanupClosePushL(line); + // open call + _LIT(KDoubleColon, "::"); + TBuf<256> name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(lineName); + name.Append(KDoubleColon); + + RMobileCall call; + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + CleanupClosePushL(call); + + TRequestStatus requestStatus; + _LIT(KSomeNumber, "123456789"); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TInt expecteCallId = 0; + + RMobileCall::TMobileCallParamsV7 callParams; + RMobileCall::TMobileCallParamsV7Pckg pckgCallParams(callParams); + RMobileCall::TMobileCallInfoV8 callInfo; + callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParams.iInterval = 100; + callParams.iWaitForDialTone = RCall::EDialToneWait; + callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParams.iCug.iExplicitInvoke = EFalse; + callParams.iCug.iCugIndex = 0xFFFF; + callParams.iCug.iSuppressPrefCug = EFalse; + callParams.iCug.iSuppressOA = EFalse; + callParams.iAutoRedial = EFalse; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + callInfo.iService = mobileService; + callInfo.iStatus = RMobileCall::EStatusUnknown; + callInfo.iCallId =-1; + callInfo.iExitCode =0; + callInfo.iEmergency =0; + callInfo.iForwarded =0; + callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; + callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; + + + callInfo.iDialledParty.iTelNumber.Copy( KSomeNumber ); + callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; + callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; + + TMockLtsyCallData2< RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV8 > + mockCallData(expecteCallId, mobileService, callParams, callInfo); + mockCallData.SerialiseL(expectData); + + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + TInt callId = 1; + + completeData.Close(); + TMockLtsyCallData1 callInfoData(callId, mobileService, callInfo); + callInfoData.SerialiseL(completeData); + //Complete Mobile Call Info in order to set the call ID + iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, completeData); + + TMockLtsyCallData0 mockDataComplete(callId, mobileService); + completeData.Close(); + mockDataComplete.SerialiseL(completeData); + // Complete the Dial + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + RCall::TCallParams callParamsX; + callParamsX.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX.iInterval = 100; + callParamsX.iWaitForDialTone = RCall::EDialToneWait; + TPckg pckgCallParamsX(callParamsX); + + call.Dial(requestStatus, pckgCallParamsX, KSomeNumber); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5,this); + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::Dial for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RCall::Dial for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV7 callParams; + callParams.iInterval = 100; + callParams.iCug.iCugIndex = 0xFFFF; + callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParams.iWaitForDialTone = RCall::EDialToneWait; + callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParams.iCug.iExplicitInvoke = EFalse; + callParams.iCug.iSuppressPrefCug = EFalse; + callParams.iCug.iSuppressOA = EFalse; + callParams.iAutoRedial = EFalse; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + callInfo.iStatus = RMobileCall::EStatusUnknown; + callInfo.iCallId =-1; + callInfo.iExitCode =0; + callInfo.iEmergency =0; + callInfo.iForwarded =0; + callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; + callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; + + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockCallData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + RCall::TCallParams callParamsX; + TPckg pckgCallParamsX(callParamsX); + callParamsX.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX.iInterval = 100; + callParamsX.iWaitForDialTone = RCall::EDialToneWait; + + //------------------------------------------------------------------------- + // Test cancelling of RCall::Dial + // before than LTSY sends any completions + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + call.CancelAsyncRequest(EEtelCallDial); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusDialling; + TMockLtsyCallData1 mockCallDataStatus(callId, mobileService, mobileCallStatus); + completeData.Close(); + mockCallDataStatus.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + + expectData.Close(); + mockCallData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + User::WaitForRequest(mockLtsyStatus); + + // Cancelled Dial request. After this CTSY hangs up the call and it goes to idle state. + + RMobileCall::TMobileCallStatus mobileCallStatus2 = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockCallDataStatus2(callId, mobileService, mobileCallStatus2); + completeData.Close(); + mockCallDataStatus2.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, completeData); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrCancel, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + //------------------------------------------------------------------------- + // Test cancelling of RCall::Dial + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + completeData.Close(); + mockCallDataStatus.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + + User::WaitForRequest(mockLtsyStatus); + + expectData.Close(); + mockCallData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + // Cancelled Dial request. After this CTSY hangs up the call and it goes to idle state. + call.CancelAsyncRequest(EEtelCallDial); + completeData.Close(); + mockCallDataStatus2.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, completeData); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrCancel, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + CleanupStack::PopAndDestroy(4); // expectData, completeData, this, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial with bad parameter data for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial with bad parameter data for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0003L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test passing wrong version of parameters to + // RCall::Dial + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 paramsV1; + TPckg pckgParamsV1(paramsV1); + + call.Dial(requestStatus, pckgParamsV1, KPhoneNumber); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrArgument, requestStatus.Int()); + + call.Close(); + CleanupStack::PopAndDestroy(&call); + + //------------------------------------------------------------------------- + // Test B: Test passing wrong descriptor size to parameter in + // RCall::Dial + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + _LIT8(KTempDesC8,"A"); + TBuf8<1> tempDes(KTempDesC8); + + call.Dial(requestStatus, tempDes, KPhoneNumber); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrArgument, requestStatus.Int()); + + call.Close(); + CleanupStack::PopAndDestroy(&call); + + //------------------------------------------------------------------------- + // Test C: Test passing empty descriptor size to parameter in + // RCall::Dial + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + TBuf8<1> nullDes(KNullDesC8); + + // If aCallParams is empty it is handled as there are no call parameters + // and CTSY uses default values + call.Dial(requestStatus, nullDes, KPhoneNumber); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(&call); + CleanupStack::PopAndDestroy(4); // completeData, expectData, line, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::Dial for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::Dial for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RCall call1; + RCall call2; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber1, "101632960000"); + _LIT(KPhoneNumber2, "654654864531"); + + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV7 callParams1; + callParams1.iInterval = 100; + callParams1.iCug.iCugIndex = 0xFFFF; + callParams1.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParams1.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParams1.iWaitForDialTone = RCall::EDialToneWait; + callParams1.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParams1.iCug.iExplicitInvoke = EFalse; + callParams1.iCug.iSuppressPrefCug = EFalse; + callParams1.iCug.iSuppressOA = EFalse; + callParams1.iAutoRedial = EFalse; + + RMobileCall::TMobileCallParamsV7 callParams2; + callParams2.iInterval = 200; + callParams2.iCug.iCugIndex = 0xFFFF; + callParams2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOn; + callParams2.iSpeakerVolume =RCall::EMonitorSpeakerVolumeMedium; + callParams2.iWaitForDialTone = RCall::EDialToneWait; + callParams2.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParams2.iCug.iExplicitInvoke = EFalse; + callParams2.iCug.iSuppressPrefCug = EFalse; + callParams2.iCug.iSuppressOA = EFalse; + callParams2.iAutoRedial = EFalse; + + + + RMobileCall::TMobileCallInfoV8 callInfo1; + callInfo1.iDialledParty.iTelNumber.Copy(KPhoneNumber1); + callInfo1.iService = mobileService; + callInfo1.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + callInfo1.iStatus = RMobileCall::EStatusUnknown; + callInfo1.iCallId =-1; + callInfo1.iExitCode =0; + callInfo1.iEmergency =0; + callInfo1.iForwarded =0; + callInfo1.iPrivacy = RMobilePhone::EPrivacyUnspecified; + callInfo1.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; + + + RMobileCall::TMobileCallInfoV8 callInfo2; + callInfo2.iDialledParty.iTelNumber.Copy(KPhoneNumber2); + callInfo2.iService = mobileService; + callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + callInfo2.iStatus = RMobileCall::EStatusUnknown; + callInfo2.iCallId =-1; + callInfo2.iExitCode =0; + callInfo2.iEmergency =0; + callInfo2.iForwarded =0; + callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified; + callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; + + TMockLtsyCallData2 + mockData21(0, mobileService, callParams1, callInfo1); + + TMockLtsyCallData2 + mockData22(0, mobileService, callParams2, callInfo2); + + TMockLtsyCallData0 mockData01(callId1, mobileService); + TMockLtsyCallData0 mockData02(callId2, mobileService); + + RCall::TCallParams callParamsX1; + TPckg pckgCallParamsX1(callParamsX1); + callParamsX1.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX1.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX1.iInterval = 100; + callParamsX1.iWaitForDialTone = RCall::EDialToneWait; + + RCall::TCallParams callParamsX2; + TPckg pckgCallParamsX2(callParamsX2); + callParamsX2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOn; + callParamsX2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium; + callParamsX2.iInterval = 200; + callParamsX2.iWaitForDialTone = RCall::EDialToneNoWait; + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData21.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + call1.Dial(requestStatus1, pckgCallParamsX1, KPhoneNumber1); + User::After(1000); + + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgCallParamsX2, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, expectData, completeData, this + // line1, line2 + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + RCall::TCallParams callParamsX; + TPckg pckgCallParamsX(callParamsX); + callParamsX.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX.iInterval = 100; + callParamsX.iWaitForDialTone = RCall::EDialToneWait; + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::Dial + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + CleanupStack::PopAndDestroy(4); // expectData, completeData, this, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006 +@SYMDEF DEF127552 +@SYMREQ 7745 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT + +N.B. As the test case BA-CTSY-CCON-CD-0006 has a very long running time, it is split into sub-test cases. +The rationale for that is as following: When the call duration of a test case exceeds 10sec, CTYS sends +a life time update to LTSY. If a test case duration is at the border of ~10sec, the life time update +notification is completed depending on the speed of working environment. It varies machine to machine +or board to board. Therefore, BA-CTSY-CCON-CD-0006 is divided into smaller parts where each part takes +far less than 10sec. +*/ +void CCTsyCallControlFU::TestDial0006L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileDataCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParams.iCug.iExplicitInvoke = EFalse; + callParams.iCug.iSuppressPrefCug = EFalse; + callParams.iCug.iSuppressOA = EFalse; + callParams.iAutoRedial = EFalse; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + TPckg pckgMockParams1(callParams); + + RCall::TCallParams callParamsX; + + callParamsX.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX.iInterval = 100; + callParamsX.iWaitForDialTone = RCall::EDialToneWait; + + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RCall::Dial when result is not cached. + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST D (Reloaded): Successful completion request of + // RCall::Dial with TCallParams when result is not cached. + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileDataCallParamsV8 callParamsDefault; + callParamsDefault.iInterval = 4; + callParamsDefault.iCug.iCugIndex = 0xFFFF; + callParamsDefault.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParamsDefault.iCug.iExplicitInvoke = EFalse; + callParamsDefault.iCug.iSuppressPrefCug = EFalse; + callParamsDefault.iCug.iSuppressOA = EFalse; + callParamsDefault.iAutoRedial = EFalse; + + TMockLtsyCallData2 + mockData3(0, mobileService, callParamsDefault, callInfo); + + expectData.Close(); + mockData3.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + TPckg pckgCallParamsX(callParamsX); // passing TCallParams + + // we are dialing the call: + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006b +@SYMDEF DEF127552 +@SYMREQ 7745 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls. It is in connection to BA-CTSY-CCON-CD-0006. +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006bL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileDataCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + TPckg pckgMockParams1(callParams); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::Dial + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : to increase CMmDataCallTsy::Dial coverage + // covers "else if ( RMobileCall::EStatusIdle != iMobileCallStatus )" condition + //------------------------------------------------------------------------- + + TName incomingCallName; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // open new call + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + //------------------------------------------------------------------------- + // close incoming call + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = EFalse; + RMobilePhone::TMobileService mobileServiceX = RMobilePhone::ECircuitDataService; + TMockLtsyCallData2 mockData2x(callId, mobileServiceX, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockData2x.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmDataCallTsy::Dial coverage + // covers "else" condition in case of impossible of conditions + // "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )", + // "else if ( RMobileCall::EStatusIdle != iMobileCallStatus )" and + // "else if ( 0 < dialHandle )" + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband; + TInt callId3 = 3; + TName incomingCallName3; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId3, incomingCallName3, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusDisconnecting; + TInt callId2 = 2; + TName incomingCallName2; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusRinging; + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrEtelCallAlreadyActive, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmDataCallTsy::Dial coverage + // covers "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )" condition + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TRfStateInfo rfInfo = ERfsStateInfoInactive; + TMockLtsyData1 mockData1(rfInfo); + expectData.Close(); + mockData1.SerialiseL(expectData); + iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + rfInfo = (TRfStateInfo) 0; + TMockLtsyData1 mockDataRf(rfInfo); + expectData.Close(); + mockDataRf.SerialiseL(expectData); + iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // call CMmVoiceCallTsy::CompleteNotifyStatusChange for setting + // iMobileCallStatus = RMobileCall::EStatusIdle. + RMobileCall::TMobileCallStatus mobileCallSt = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockCallDataStatus2(callId, mobileService, mobileCallSt); + completeData.Close(); + mockCallDataStatus2.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // Tests for TMobileDataCallParamsV2 + + RMobileCall::TMobileDataCallParamsV2 dataCallParams2; + dataCallParams2.iInterval = 4; + dataCallParams2.iCug.iCugIndex = 0xFFFF; + dataCallParams2.iQoS = RMobileCall::EQosTransparentPreferred; + dataCallParams2.iBearerMode = RMobileCall::EMulticallShareBearer; + + TMockLtsyCallData2 + mockDataCallParams2(0, mobileService, dataCallParams2, callInfo); + + TPckg pckgMockDataCallParams2(dataCallParams2); + + //------------------------------------------------------------------------- + // TEST A2: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + // expectData.Close(); + mockDataCallParams2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgMockDataCallParams2, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B2: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgMockDataCallParams2, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C2: Successful completion request of + // RCall::Dial when result is not cached + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, pckgMockDataCallParams2, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +// Returns sample call information variable +void GetCallInformation8(RMobileCall::TMobileCallInfoV8& aCallInformation, const TDesC& aPhoneNumber, RMobilePhone::TMobileService aMobileService) + { + aCallInformation.iDialledParty.iTelNumber.Copy(aPhoneNumber); + aCallInformation.iService = aMobileService; + aCallInformation.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + aCallInformation.iAlphaId.Copy(_L("Alpha Id")); + aCallInformation.iValid |= RMobileCall::KCallAlphaId; + aCallInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM;; + aCallInformation.iValid |= RMobileCall::KCallParamOrigin; + } + +// Returns sample call params variable +void GetCallParams8(RMobileCall::TMobileDataCallParamsV8& aDataCallParams) + { + aDataCallParams.iInterval = 4; + aDataCallParams.iCug.iCugIndex = 0xFFFF; + aDataCallParams.iQoS = RMobileCall::EQosTransparentPreferred; + aDataCallParams.iBearerMode = RMobileCall::EMulticallShareBearer; + aDataCallParams.iSubAddress.Copy(_L("An Unknown SubAddress")); + aDataCallParams.iAlphaId.Copy(_L("Alpha Id")); + aDataCallParams.iCallParamOrigin = RMobileCall::EOriginatorSIM; + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006c +@SYMDEF DEF127552 +@SYMREQ 7745 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls. It is in connection to BA-CTSY-CCON-CD-0006. +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006cL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "135468456456"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Tests for TMobileDataCallParamsV8 + + RMobileCall::TMobileCallInfoV8 callInformation; + GetCallInformation8(callInformation, KPhoneNumber(), mobileService); + + RMobileCall::TMobileDataCallParamsV8 dataCallParams8; + GetCallParams8(dataCallParams8); + + TMockLtsyCallData2 + mockDataCallParams8(0, mobileService, dataCallParams8, callInformation); + + TPckg pckgMockDataCallParams8(dataCallParams8); + + //------------------------------------------------------------------------- + // TEST A3: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgMockDataCallParams8, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B3: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgMockDataCallParams8, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C3: Successful completion request of + // RCall::Dial when result is not cached + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, pckgMockDataCallParams8, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); // call + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006d +@SYMDEF DEF127552 +@SYMREQ 7745 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls. It is in connection to BA-CTSY-CCON-CD-0006. +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006dL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + _LIT(KPhoneNumber, "135468456456"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + TMockLtsyCallData0 mockData0(callId, mobileService); + + RMobileCall::TMobileCallInfoV8 callInformation; + GetCallInformation8(callInformation, KPhoneNumber(), mobileService); + + RMobileCall::TMobileDataCallParamsV8 dataCallParams8; + GetCallParams8(dataCallParams8); + + TMockLtsyCallData2 + mockDataCallParams8(0, mobileService, dataCallParams8, callInformation); + + TPckg pckgMockDataCallParams8(dataCallParams8); + + //------------------------------------------------------------------------- + // Tests for default parameters + + //------------------------------------------------------------------------- + // TEST A4: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B4: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C4: Successful completion request of + // RCall::Dial when result is not cached + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCallParams8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); // call + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006e +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls with HscsdCallParams. It is in connection to BA-CTSY-CCON-CD-0006 +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006eL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + //------------------------------------------------------------------------- + // Test: Test passing RMobileCall::TMobileHscsdCallParamsV1 to + // RCall::Dial + //------------------------------------------------------------------------- + + RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams; + + TMockLtsyCallData2 + mockHscsdData(0, mobileService, hscsdCallParams, callInfo); + + TPckg pckgMockHscsdParams1(hscsdCallParams); + + //------------------------------------------------------------------------- + // TEST A4: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgMockHscsdParams1, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B4: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + TMockLtsyCallData0 mockData0(callId, mobileService); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgMockHscsdParams1, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C4: Successful completion request of + // RCall::Dial when result is not cached + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, pckgMockHscsdParams1, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006f +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls with HscsdCallParams. It is in connection to BA-CTSY-CCON-CD-0006 +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006fL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "135468456456"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + //------------------------------------------------------------------------- + // Test: Test passing RMobileCall::TMobileHscsdCallParamsV2 to + // RCall::Dial + //------------------------------------------------------------------------- + + RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2; + + TMockLtsyCallData2 + mockHscsdData2(0, mobileService, hscsdCallParams2, callInfo); + + TPckg pckgMockHscsdParams2(hscsdCallParams2); + + //------------------------------------------------------------------------- + // TEST A5: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgMockHscsdParams2, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B5: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + TMockLtsyCallData0 mockData0(callId, mobileService); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgMockHscsdParams2, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C5: Successful completion request of + // RCall::Dial when result is not cached + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, pckgMockHscsdParams2, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006g +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls with HscsdCallParams.It is in connection to BA-CTSY-CCON-CD-0006 +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006gL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test: Test passing RMobileCall::TMobileHscsdCallParamsV7 to + // RCall::Dial + //------------------------------------------------------------------------- + + RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7; + + // TMobileHscsdCallParamsV7 params for Dial + hscsdCallParams7.iInterval = 4; + hscsdCallParams7.iCug.iCugIndex = 0xFFFF; + hscsdCallParams7.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff; + hscsdCallParams7.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium; + hscsdCallParams7.iWaitForDialTone = RCall::EDialToneWait; + hscsdCallParams7.iQoS = RMobileCall::EQosTransparentPreferred; + hscsdCallParams7.iV42bisReq = RMobileCall::EV42bisTxDirection; + hscsdCallParams7.iWantedRxTimeSlots = 2; + hscsdCallParams7.iCodings = 3; + hscsdCallParams7.iBearerMode = RMobileCall::EMulticallShareBearer; + hscsdCallParams7.iAlphaId.Copy(_L("Alpha Id")); + hscsdCallParams7.iCallParamOrigin = RMobileCall::EOriginatorSIM; + + RMobileCall::TMobileCallInfoV8 callInformation; + GetCallInformation8(callInformation, KPhoneNumber(), mobileService); + + TMockLtsyCallData2 + mockHscsdData7(0, mobileService, hscsdCallParams7, callInformation); + + TPckg pckgMockHscsdParams7(hscsdCallParams7); + + //------------------------------------------------------------------------- + // TEST A6: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData7.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgMockHscsdParams7, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B6: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData7.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgMockHscsdParams7, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C6: Successful completion request of + // RCall::Dial when result is not cached + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData7.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, pckgMockHscsdParams7, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006h +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls with HscsdCallParams.It is in connection to BA-CTSY-CCON-CD-0006 +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006hL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + _LIT(KPhoneNumber, "135468456456"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test: Test passing RMobileCall::TMobileHscsdCallParamsV8 to + // RCall::Dial + //------------------------------------------------------------------------- + + RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8; + + // TMobileHscsdCallParamsV8 params for Dial + hscsdCallParams8.iInterval = 2; + hscsdCallParams8.iCug.iCugIndex = 0xFFFF; + hscsdCallParams8.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff; + hscsdCallParams8.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium; + hscsdCallParams8.iWaitForDialTone = RCall::EDialToneWait; + hscsdCallParams8.iQoS = RMobileCall::EQosTransparentPreferred; + hscsdCallParams8.iV42bisReq = RMobileCall::EV42bisTxDirection; + hscsdCallParams8.iWantedRxTimeSlots = 2; + hscsdCallParams8.iCodings = 3; + hscsdCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer; + hscsdCallParams8.iAlphaId.Copy(_L("Alpha Id")); + hscsdCallParams8.iSubAddress.Copy(_L("An Unknown SubAddress")); + hscsdCallParams8.iCallParamOrigin = RMobileCall::EOriginatorSIM; + + RMobileCall::TMobileCallInfoV8 callInformation; + GetCallInformation8(callInformation, KPhoneNumber(), mobileService); + + TMockLtsyCallData2 + mockHscsdData8(0, mobileService, hscsdCallParams8, callInformation); + + TPckg pckgMockHscsdParams8(hscsdCallParams8); + + //------------------------------------------------------------------------- + // TEST A7: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNotSupported); + + call.Dial(requestStatus, pckgMockHscsdParams8, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST B7: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrGeneral, completeData); + + call.Dial(requestStatus, pckgMockHscsdParams8, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST C6: Successful completion request of + // RCall::Dial when result is not cached + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdData8.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // we are dialing the call: + call.Dial(requestStatus, pckgMockHscsdParams8, KPhoneNumber); + + CompleteDialStatusNotificationsL(call, callId, mobileService ); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CompleteCallDisconnectNotificationsL(callId, mobileService); + + call.Close(); + CleanupStack::PopAndDestroy(1); + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0006i +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for data calls with minimal parameters (RCall::TCallParams) +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0006iL() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + TInt errorCode = KErrNone; + + //-- For Voice1 ------------------------- + + TBuf<256> lineName(KMmTsyDataLineName); + // Open new line + RLine line; + errorCode = line.Open(iPhone, lineName); + ASSERT_EQUALS(KErrNone, errorCode); + CleanupClosePushL(line); + // open call + _LIT(KDoubleColon, "::"); + TBuf<256> name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(lineName); + name.Append(KDoubleColon); + + RMobileCall call; + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + CleanupClosePushL(call); + + TRequestStatus requestStatus; + _LIT(KSomeNumber, "123456789"); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + TInt expecteCallId = 0; + + RMobileCall::TMobileDataCallParamsV8 callParams; + RMobileCall::TMobileDataCallParamsV8Pckg pckgCallParams(callParams); + RMobileCall::TMobileCallInfoV8 callInfo; + callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParams.iInterval = 100; + callParams.iWaitForDialTone = RCall::EDialToneWait; + callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParams.iCug.iExplicitInvoke = EFalse; + callParams.iCug.iCugIndex = 0xFFFF; + callParams.iCug.iSuppressPrefCug = EFalse; + callParams.iCug.iSuppressOA = EFalse; + callParams.iAutoRedial = EFalse; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + callInfo.iService = mobileService; + callInfo.iStatus = RMobileCall::EStatusUnknown; + callInfo.iCallId =-1; + callInfo.iExitCode =0; + callInfo.iEmergency =0; + callInfo.iForwarded =0; + callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; + callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; + + + callInfo.iDialledParty.iTelNumber.Copy( KSomeNumber ); + callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; + callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber; + + TMockLtsyCallData2< RMobileCall::TMobileDataCallParamsV8, RMobileCall::TMobileCallInfoV8 > + mockCallData(expecteCallId, mobileService, callParams, callInfo); + mockCallData.SerialiseL(expectData); + + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + TInt callId = 1; + + completeData.Close(); + TMockLtsyCallData1 callInfoData(callId, mobileService, callInfo); + callInfoData.SerialiseL(completeData); + //Complete Mobile Call Info in order to set the call ID + iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, completeData); + + TMockLtsyCallData0 mockDataComplete(callId, mobileService); + completeData.Close(); + mockDataComplete.SerialiseL(completeData); + // Complete the Dial + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + RCall::TCallParams callParamsX; + callParamsX.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX.iInterval = 100; + callParamsX.iWaitForDialTone = RCall::EDialToneWait; + TPckg pckgCallParamsX(callParamsX); + + call.Dial(requestStatus, pckgCallParamsX, KSomeNumber); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5,this); + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::Dial for data calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0007L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "135468456456"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileDataCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + + RMobileCall::TMobileCallStatus mobileCallStatus2 = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockCallDataStatus2(callId, mobileService, mobileCallStatus2); + completeData.Close(); + mockCallDataStatus2.SerialiseL(completeData); + + + // Call Specific data + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + TPckg pckgMockParams1(callParams); + + expectData.Close(); + mockData2.SerialiseL(expectData); + + DialDataCallAndCancelL(line,pckgMockParams1,expectData,completeData); + + //------------------------------------------------------------------ + // TMobileDataCallParamsV2 + + RMobileCall::TMobileDataCallParamsV2 dataCallParams2; + dataCallParams2.iInterval = 4; + dataCallParams2.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockDataCall2(0, mobileService, dataCallParams2, callInfo); + + TPckg pckgMockDataCallParams2(dataCallParams2); + + expectData.Close(); + mockDataCall2.SerialiseL(expectData); + + DialDataCallAndCancelL(line,pckgMockDataCallParams2,expectData,completeData); + + //------------------------------------------------------------------ + // TMobileDataCallParamsV8 + + RMobileCall::TMobileDataCallParamsV8 dataCallParams8; + dataCallParams8.iInterval = 4; + dataCallParams8.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockDataCall8(0, mobileService, dataCallParams8, callInfo); + + TPckg pckgMockDataCallParams8(dataCallParams8); + + expectData.Close(); + mockDataCall8.SerialiseL(expectData); + + DialDataCallAndCancelL(line,pckgMockDataCallParams8,expectData,completeData); + + //------------------------------------------------------------------ + // TMobileHscsdCallParamsV1 + + RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams; + hscsdCallParams.iInterval = 4; + hscsdCallParams.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockHscsdCall(0, mobileService, hscsdCallParams, callInfo); + + TPckg pckgMockHscsdCallParams(hscsdCallParams); + + expectData.Close(); + mockHscsdCall.SerialiseL(expectData); + + DialDataCallAndCancelL(line,pckgMockHscsdCallParams,expectData,completeData); + + //------------------------------------------------------------------ + // TMobileHscsdCallParamsV2 + + RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2; + hscsdCallParams2.iInterval = 4; + hscsdCallParams2.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockHscsdCall2(0, mobileService, hscsdCallParams2, callInfo); + + TPckg pckgMockHscsdCallParams2(hscsdCallParams2); + + expectData.Close(); + mockHscsdCall2.SerialiseL(expectData); + + DialDataCallAndCancelL(line,pckgMockHscsdCallParams2,expectData,completeData); + + //------------------------------------------------------------------ + // TMobileHscsdCallParamsV7 + + RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7; + hscsdCallParams7.iInterval = 4; + hscsdCallParams7.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockHscsdCall7(0, mobileService, hscsdCallParams7, callInfo); + + TPckg pckgMockHscsdCallParams7(hscsdCallParams7); + + expectData.Close(); + mockHscsdCall7.SerialiseL(expectData); + + DialDataCallAndCancelL(line,pckgMockHscsdCallParams7,expectData,completeData); + + + //------------------------------------------------------------------ + // TMobileHscsdCallParamsV8 + + RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8; + hscsdCallParams8.iInterval = 4; + hscsdCallParams8.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockHscsdCall8(0, mobileService, hscsdCallParams8, callInfo); + + TPckg pckgMockHscsdCallParams8(hscsdCallParams8); + + expectData.Close(); + mockHscsdCall8.SerialiseL(expectData); + + DialDataCallAndCancelL(line,pckgMockHscsdCallParams8,expectData,completeData); + CleanupStack::PopAndDestroy(4); // expectData, completeData, this, this + } + +void +CCTsyCallControlFU::DialDataCallAndCancelL(RLine& aLine,const TDesC8& aCallData,RBuf8& expectData,RBuf8& completeData) + { + // open new call + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + _LIT(KPhoneNumber, "135468456456"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + TName name; + RCall call; + CleanupClosePushL(call); + errorCode = call.OpenNewCall(aLine, name); + ASSERT_EQUALS(KErrNone, errorCode); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + call.Dial(requestStatus, aCallData, KPhoneNumber); + + User::WaitForRequest(mockLtsyStatus); + + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockHangupData(callId, mobileService, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockHangupData.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.CancelAsyncRequest(EEtelCallDial); + + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, completeData); + + User::WaitForRequest(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrCancel, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + } + + + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial with bad parameter data for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial with bad parameter data for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0008L() + { + +// This test should test sending bad parameter data for Dial +// If this API does not have any parameters, then remove this test completely. + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + TInt8 callParams; // bad param + TPckg paramPckg(callParams); + + //------------------------------------------------------------------------- + // Test A: Test passing wrong version of parameters to + // RCall::Dial + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + call.Dial(requestStatus, paramPckg, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrArgument, requestStatus.Int()); + + call.Close(); + CleanupStack::PopAndDestroy(1); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::Dial for data calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0009L() + { + + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RCall call1; + RCall call2; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber1, "101632960000"); + _LIT(KPhoneNumber2, "654654864531"); + + TInt callId1 = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileDataCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV8 callInfo1; + callInfo1.iDialledParty.iTelNumber.Copy(KPhoneNumber1); + callInfo1.iService = mobileService; + callInfo1.iValid = RMobileCall::KCallDialledParty |RMobileCall::KCallAlternating; + + RMobileCall::TMobileCallInfoV8 callInfo2; + callInfo2.iDialledParty.iTelNumber.Copy(KPhoneNumber2); + callInfo2.iService = mobileService; + callInfo2.iValid = RMobileCall::KCallDialledParty |RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData21(0, mobileService, callParams, callInfo1); + + TMockLtsyCallData0 mockData01(callId1, mobileService); + + TPckg pckgMockParams1(callParams); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData21.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call1.Dial(requestStatus1, pckgMockParams1, KPhoneNumber1); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgMockParams1, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //----------------------------------------------------------------------- + // TMobileDataCallParamsV2 + RMobileCall::TMobileDataCallParamsV2 dataCallParams2; + dataCallParams2.iInterval = 4; + dataCallParams2.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockDataCall21(0, mobileService, dataCallParams2, callInfo1); + + TPckg pckgMockDataCallParams2(dataCallParams2); + + //------------------------------------------------------------------------- + // Test A2: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCall21.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call1.Dial(requestStatus1, pckgMockDataCallParams2, KPhoneNumber1); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgMockDataCallParams2, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //----------------------------------------------------------------------- + // TMobileDataCallParamsV8 + + RMobileCall::TMobileDataCallParamsV8 dataCallParams8; + dataCallParams8.iInterval = 2; + dataCallParams8.iCug.iCugIndex = 0xFFFF; + dataCallParams8.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff; + dataCallParams8.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium; + dataCallParams8.iWaitForDialTone = RCall::EDialToneWait; + dataCallParams8.iQoS = RMobileCall::EQosTransparentPreferred; + dataCallParams8.iV42bisReq = RMobileCall::EV42bisTxDirection; + dataCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer; + dataCallParams8.iSubAddress.Copy(_L("An Unknown SubAddress")); + dataCallParams8.iCallParamOrigin = RMobileCall::EOriginatorSIM; + dataCallParams8.iAlphaId.Copy(_L("Alpha Id")); + + RMobileCall::TMobileCallInfoV8 callInformation; + callInformation.iDialledParty.iTelNumber.Copy(KPhoneNumber1); + callInformation.iService = mobileService; + callInformation.iValid |= RMobileCall::KCallDialledParty; + callInformation.iValid |= RMobileCall::KCallAlternating; + callInformation.iAlphaId.Copy(_L("Alpha Id")); + callInformation.iValid |= RMobileCall::KCallAlphaId; + callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM; + callInformation.iValid |= RMobileCall::KCallParamOrigin; + + TMockLtsyCallData2 + mockDataCall81(0, mobileService, dataCallParams8, callInformation); + + TPckg pckgMockDataCallParams8(dataCallParams8); + + //------------------------------------------------------------------------- + // Test A3: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockDataCall81.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call1.Dial(requestStatus1, pckgMockDataCallParams8, KPhoneNumber1); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgMockDataCallParams8, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + // Done ! + CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, expectData, completeData, this + // line1, line2 + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0009b +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::Dial for data calls with HscsdCallParams. It is in connection to BA-CTSY-CCON-CD-0009 +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0009bL() + { + + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RCall call1; + RCall call2; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber1, "101632960000"); + _LIT(KPhoneNumber2, "654654864531"); + + TInt callId1 = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileCallInfoV8 callInfo1; + callInfo1.iDialledParty.iTelNumber.Copy(KPhoneNumber1); + callInfo1.iService = mobileService; + callInfo1.iValid = RMobileCall::KCallDialledParty |RMobileCall::KCallAlternating; + + RMobileCall::TMobileCallInfoV8 callInfo2; + callInfo2.iDialledParty.iTelNumber.Copy(KPhoneNumber2); + callInfo2.iService = mobileService; + callInfo2.iValid = RMobileCall::KCallDialledParty |RMobileCall::KCallAlternating; + + //----------------------------------------------------------------------- + // TMobileHscsdCallParamsV1 + RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams1; + hscsdCallParams1.iInterval = 4; + hscsdCallParams1.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockHscsdCall11(0, mobileService, hscsdCallParams1, callInfo1); + + TPckg pckgMockHscsdCallParams1(hscsdCallParams1); + TMockLtsyCallData0 mockData01(callId1, mobileService); + //------------------------------------------------------------------------- + // Test A4: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdCall11.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call1.Dial(requestStatus1, pckgMockHscsdCallParams1, KPhoneNumber1); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgMockHscsdCallParams1, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //----------------------------------------------------------------------- + // TMobileHscsdCallParamsV2 + RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2; + hscsdCallParams2.iInterval = 4; + hscsdCallParams2.iCug.iCugIndex = 0xFFFF; + + TMockLtsyCallData2 + mockHscsdCall21(0, mobileService, hscsdCallParams2, callInfo1); + + TPckg pckgMockHscsdCallParams2(hscsdCallParams2); + + //------------------------------------------------------------------------- + // Test A5: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdCall21.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call1.Dial(requestStatus1, pckgMockHscsdCallParams2, KPhoneNumber1); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgMockHscsdCallParams2, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //----------------------------------------------------------------------- + // TMobileHscsdCallParamsV7 + RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7; + hscsdCallParams7.iInterval = 4; + hscsdCallParams7.iCug.iCugIndex = 0xFFFF; + hscsdCallParams7.iAlphaId.Copy(_L("Alpha Id")); + hscsdCallParams7.iCallParamOrigin = RMobileCall::EOriginatorSIM; + + RMobileCall::TMobileCallInfoV8 callInformation; + callInformation.iDialledParty.iTelNumber.Copy(KPhoneNumber1); + callInformation.iService = mobileService; + callInformation.iValid |= RMobileCall::KCallDialledParty; + callInformation.iValid |= RMobileCall::KCallAlternating; + callInformation.iAlphaId.Copy(_L("Alpha Id")); + callInformation.iValid |= RMobileCall::KCallAlphaId; + callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM; + callInformation.iValid |= RMobileCall::KCallParamOrigin; + + TMockLtsyCallData2 + mockHscsdCall71(0, mobileService, hscsdCallParams7, callInformation); + + TPckg pckgMockHscsdCallParams7(hscsdCallParams7); + + //------------------------------------------------------------------------- + // Test A6: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdCall71.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + call1.Dial(requestStatus1, pckgMockHscsdCallParams7, KPhoneNumber1); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgMockHscsdCallParams7, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + // Done ! + CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, expectData, completeData, this + // line1, line2 + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-0009c +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::Dial for data calls with HscsdCallParamsV8. It is in connection to Test support in CTSY for multiple client requests to RCall::Dial for data calls with HscsdCallParamsV8. It is in connection to BA-CTSY-CCON-CD-0009b +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::Dial for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial0009cL() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RCall call1; + RCall call2; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber1, "101632960000"); + _LIT(KPhoneNumber2, "654654864531"); + + TInt callId1 = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileCallInfoV8 callInformation; + callInformation.iDialledParty.iTelNumber.Copy(KPhoneNumber1); + callInformation.iService = mobileService; + callInformation.iValid |= RMobileCall::KCallDialledParty; + callInformation.iValid |= RMobileCall::KCallAlternating; + callInformation.iAlphaId.Copy(_L("Alpha Id")); + callInformation.iValid |= RMobileCall::KCallAlphaId; + callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM; + callInformation.iValid |= RMobileCall::KCallParamOrigin; + + //----------------------------------------------------------------------- + // TMobileHscsdCallParamsV8 + RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8; + hscsdCallParams8.iInterval = 4; + hscsdCallParams8.iCug.iCugIndex = 0xFFFF; + hscsdCallParams8.iAlphaId.Copy(_L("Alpha Id")); + hscsdCallParams8.iCallParamOrigin = RMobileCall::EOriginatorSIM; + + TMockLtsyCallData2 + mockHscsdCall81(0, mobileService, hscsdCallParams8, callInformation); + + TPckg pckgMockHscsdCallParams8(hscsdCallParams8); + + //------------------------------------------------------------------------- + // Test A7: Test multiple clients requesting RCall::Dial + //------------------------------------------------------------------------- + + // call first clinet + // open new call1 + CleanupClosePushL(call1); + errorCode = call1.OpenNewCall(line1, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockHscsdCall81.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber1); + call1.Dial(requestStatus1, pckgMockHscsdCallParams8, KPhoneNumber1); + + TMockLtsyCallData0 mockData01(callId1, mobileService); + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // call second clinet + // open new call + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line2, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call2.Dial(requestStatus2, pckgMockHscsdCallParams8, KPhoneNumber2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call1.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + // Done ! + CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, expectData, completeData, this + // line1, line2 + } + + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-00010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial with timeout for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial and tests for timeout for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial00010L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileDataCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + TPckg pckgMockParams1(callParams); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::Dial + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + CleanupStack::PopAndDestroy(4); // expectData, completeData, this, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CD-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::Dial for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::Dial for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDial00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus requestStatus2; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + + RMobileCall::TMobileCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + TPckg pckgMockParams1(callParams); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::Dial + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : to increase CMmFaxCallTsy::Dial coverage + // covers "if( call->GetDialFlag() )" condition + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new call + RCall call2; + CleanupClosePushL(call2); + errorCode = call2.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.Dial(requestStatus, pckgMockParams1, KPhoneNumber); + + call2.Dial(requestStatus2, pckgMockParams1, KPhoneNumber); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmFaxCallTsy::Dial coverage + // covers "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )" condition + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TRfStateInfo rfInfo = ERfsStateInfoInactive; + TMockLtsyData1 mockData1(rfInfo); + expectData.Close(); + mockData1.SerialiseL(expectData); + iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + RCall::TCallParams callParamsX; + TPckg pckgCallParamsX(callParamsX); + callParamsX.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParamsX.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParamsX.iInterval = 100; + callParamsX.iWaitForDialTone = RCall::EDialToneWait; + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGsmOfflineOpNotAllowed, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmFaxCallTsy::Dial coverage + // covers "else if ( RMobileCall::EStatusIdle != iMobileCallStatus )" condition + //------------------------------------------------------------------------- + + TName incomingCallName; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + rfInfo = ERfsStateInfoNormal; + TMockLtsyData1 mockData1X(rfInfo); + expectData.Close(); + mockData1X.SerialiseL(expectData); + iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + call.Dial(requestStatus, pckgCallParamsX, KPhoneNumber); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + //------------------------------------------------------------------------- + // close incoming call + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = EFalse; + RMobilePhone::TMobileService mobileServiceX = RMobilePhone::EFaxService; + TMockLtsyCallData2 mockData2x(callId, mobileServiceX, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockData2x.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + TMockLtsyCallData0 mockData1(callId2, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNotSupported); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // call + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RCall::HangUp when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + CleanupStack::PopAndDestroy(1); // call + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::HangUp + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "if ( 0 < hangUpHandle || iHangUpFlag )" condition + //------------------------------------------------------------------------- + + RCall call2; + CleanupClosePushL(call2); + TRequestStatus requestStatus2; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGeneral, completeData); + call.HangUp(requestStatus); + + call2.HangUp(requestStatus2); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + // close incoming call + call.Close(); + AssertMockLtsyStatusL(); + + // close incoming call2 + CloseIncomingCallL(call2, callId, mobileService); + CleanupStack::PopAndDestroy(1); // call2 + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "if ( ( NULL != callList->GetMmCallByStatus( + // RMobileCall::EStatusConnected ) ) && + // ( NULL != callList->GetMmCallByStatus( + // RMobileCall::EStatusHold ) ) && + // ( NULL != callList->GetMmCallByStatus( + // RMobileCall::EStatusRinging ) ) )" condition + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusConnected; + callId = 3; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusRinging; + callId = 2; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusHold; + callId = 1; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + callId = 2; + hangUpCause = KErrGsmBusyUserRequest; + autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData2xx(callId, mobileService, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockData2xx.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData1.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + call.HangUp(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call for RMobileCall::EStatusRinging + callId = 2; + CloseIncomingCallL(call, callId, mobileService); + + // open call for RMobileCall::EStatusHold + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + + // close incoming call for RMobileCall::EStatusHold + callId = 1; + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + callId = 1; + mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + hangUpCause = KErrGsmBusyUserRequest; + autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData2xxx(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + expectData.Close(); + mockData2xxx.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGeneral, completeData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // call + + // + // Added for DEF139341 (Unexpected error note pops up after creating emergency call) + // Tests that CTSY treats KErrGsmReleaseByUser as a normal return code, not as an error + // (the client request should complete with KErrNone). + // + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + hangUpCause = KErrGsmBusyUserRequest; + autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData3xxx(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + expectData.Close(); + mockData3xxx.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGsmReleaseByUser, completeData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // call + // + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::HangUp for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RCall::HangUp for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test cancelling of RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call.HangUp(requestStatus); + + call.CancelAsyncRequest(EEtelCallHangUp); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + User::WaitForRequest(mockLtsyStatus); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::HangUp for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::HangUp for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RCall call1; + RCall call2; + RLine line1; + RLine line2; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName1; + TName incomingCallName2; + + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData21(callId1, mobileService, + hangUpCause, + autoStChangeDisable); + TMockLtsyCallData2 mockData22(callId2, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData01(callId1, mobileService); + TMockLtsyCallData0 mockData02(callId2, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call1); + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call2); + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData21.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call1.HangUp(requestStatus1); + + expectData.Close(); + mockData22.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData02.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call2.HangUp(requestStatus2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + // close incoming call1 + CloseIncomingCallL(call1, callId1, mobileService); + AssertMockLtsyStatusL(); + + // close incoming call2 + CloseIncomingCallL(call2, callId2, mobileService); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(2); // call1, call2 + CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, expectData, completeData, this + // line1, line2 + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + TTime t1,t2; //time stamps for measuring the Time Out + + + t1.HomeTime(); // time stamp before request + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + t2.HomeTime(); // timestamp after request + + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + TTimeIntervalSeconds diff; + TInt res = t2.SecondsFrom(t1,diff); + ASSERT_EQUALS(KErrNone, res); + if(diff.Int() < KMmCallHangUpTimeOut) + { + ERR_PRINTF3(_L("RCall::Hangup time out too short. Expected: %d Actual: %d "),KMmCallHangUpTimeOut, diff.Int()); + ASSERT(false); + } + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp0006L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNotSupported); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RCall::HangUp when result is not cached. + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::HangUp + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "if ( 0 < hangUpHandle || iHangUpFlag )" condition + //------------------------------------------------------------------------- + + RCall call2; + CleanupClosePushL(call2); + TRequestStatus requestStatus2; + + //------------------------------------------------------------------------- + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGeneral, completeData); + call.HangUp(requestStatus); + + call2.HangUp(requestStatus2); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + // close incoming call2 + call2.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "else if ( RCall::EStatusIdle == iCallStatus && + // EMultimodeCallReqHandleUnknown == dialHandle )" condition + //------------------------------------------------------------------------- + + TInt callId2 = 2; + mobileCallStatus = RMobileCall::EStatusIdle; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId2, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + call2.HangUp(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + // close incoming call2 + call2.Close(); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGeneral, completeData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + + + // + // Added for DEF139341 (Unexpected error note pops up after creating emergency call) + // Tests that CTSY treats KErrGsmReleaseByUser as a normal return code, not as an error + // (the client request should complete with KErrNone). + // + + //------------------------------------------------------------------------- + // create new incoming call + TInt callId3 = 3; + mobileCallStatus = RMobileCall::EStatusRinging; + errorCode = CreateIncomingCallL(line, callId3, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + RCall call3; + CleanupClosePushL(call3); + errorCode = call3.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyCallData2 mockData23(callId3, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData03(callId3, mobileService); + + expectData.Close(); + mockData23.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData03.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGsmReleaseByUser, completeData); + + call3.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + // + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // call3, call, line, completeData, expectData, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::HangUp for data calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RCall::HangUp for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp0007L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + //------------------------------------------------------------------------- + // Test cancelling of RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.HangUp(requestStatus); + + // cancel hang-up + // TSY has started a HangUp request and it is not possible to cancel this request + call.CancelAsyncRequest(EEtelCallHangUp); + + // CTSY hangs up the call and it goes to idle state + mobileCallStatus = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockCallData2(callId, mobileService, mobileCallStatus); + mockCallData2.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmBusyUserRequest, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call, line, expectData, completeData, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::HangUp for data calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::HangUp for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp0009L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + // Open third client + RTelServer telServer3; + ret = telServer3.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer3); + + RMobilePhone phone3; + ret = phone3.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone3); + + RCall call1; + RCall call2; + RCall call3; + RLine line1; + RLine line2; + RLine line3; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + TRequestStatus requestStatus3; + + // open new line1 + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 + errorCode = OpenNewLineLC(phone2, line2, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line3 + errorCode = OpenNewLineLC(phone3, line3, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName1; + TName incomingCallName2; + TName incomingCallName3; + + TInt callId1 = 1; + TInt callId2 = 2; + TInt callId3 = 3; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData21(callId1, mobileService, + hangUpCause, + autoStChangeDisable); + TMockLtsyCallData2 mockData22(callId2, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData01(callId1, mobileService); + TMockLtsyCallData0 mockData02(callId2, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call1); + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call2); + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call3 + + mobileCallStatus = RMobileCall::EStatusConnected; + errorCode = CreateIncomingCallL(line3, callId3, incomingCallName3, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call3); + errorCode = call3.OpenExistingCall(line3, incomingCallName3); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData21.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call1.HangUp(requestStatus1); + + expectData.Close(); + mockData22.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData02.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call2.HangUp(requestStatus2); + + hangUpCause = KErrGsmReleaseByUser; + TMockLtsyCallData2 mockData23(callId3, mobileService, + hangUpCause, + autoStChangeDisable); + TMockLtsyCallData0 mockData03(callId3, mobileService); + + expectData.Close(); + mockData23.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData03.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call3.HangUp(requestStatus3); + + User::WaitForRequest(requestStatus1); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + User::WaitForRequest(requestStatus3); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus3.Int()); + + CleanupStack::PopAndDestroy(3); // call1, call2, call3 + CleanupStack::PopAndDestroy(10, this); // phone2, telServer2, phone3, telServer3, + // expectData, completeData, this + // line1, line2, line3 + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-00010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp with timeout for data calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp and tests for timeout for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp00010L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ERR_PRINTF2(_L("$CTSYKnownFailure: defect id = %d"), 100303); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + CleanupClosePushL(call); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNotSupported); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RCall::HangUp when result is not cached. + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::HangUp + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "if ( 0 < hangUpHandle )" condition + //------------------------------------------------------------------------- + + RCall call2; + TRequestStatus requestStatus2; + + //------------------------------------------------------------------------- + errorCode = call2.OpenExistingCall(line, incomingCallName); + CleanupClosePushL(call2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGeneral, completeData); + call.HangUp(requestStatus); + + call2.HangUp(requestStatus2); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + // close incoming call2 + call2.Close(); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGeneral, completeData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + + // + // Added for DEF139341 (Unexpected error note pops up after creating emergency call) + // Tests that CTSY treats KErrGsmReleaseByUser as a normal return code, not as an error + // (the client request should complete with KErrNone). + // + + //------------------------------------------------------------------------- + // create new incoming call + TInt callId3 = 3; + mobileCallStatus = RMobileCall::EStatusRinging; + errorCode = CreateIncomingCallL(line, callId3, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + RCall call3; + CleanupClosePushL(call3); + errorCode = call3.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyCallData2 mockData23(callId3, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData03(callId3, mobileService); + + expectData.Close(); + mockData23.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData03.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrGsmReleaseByUser, completeData); + + call3.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + // + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(7, this); // expectData, completeData, this, line, call, call2, call3 + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-00011b +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp00011bL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "else if ( RCall::EStatusIdle == iCallStatus && + // EMultimodeCallReqHandleUnknown == dialHandle )" condition + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + + errorCode = call.OpenExistingCall(line, incomingCallName); + CleanupClosePushL(call); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + call.HangUp(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + CleanupStack::PopAndDestroy(5, this); // expectData, completeData, this, line, call + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-00011c +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp00011cL() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyFaxLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusConnected; + + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::Dial coverage + // covers "if ( RCall::EStatusRinging == iCallStatus )" condition + //------------------------------------------------------------------------- + + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + + errorCode = call.OpenExistingCall(line, incomingCallName); + CleanupClosePushL(call); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call.HangUp(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CleanupStack::PopAndDestroy(5, this); // expectData, completeData, this, line, call + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-00012 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::HangUp for fax calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RCall::HangUp for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp00012L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyFaxLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + //------------------------------------------------------------------------- + // Test cancelling of RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.HangUp(requestStatus); + + // cancel hang-up + // TSY has started a HangUp request and it is not possible to cancel this request + call.CancelAsyncRequest(EEtelCallHangUp); + + // CTSY hangs up the call and it goes to idle state + mobileCallStatus = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockCallData2(callId, mobileService, mobileCallStatus); + mockCallData2.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmBusyUserRequest, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call, line, expectData, completeData, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-00014 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::HangUp for fax calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RCall::HangUp for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp00014L() + { + + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RCall call1; + RCall call2; + RLine line1; + RLine line2; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 + errorCode = OpenNewLineLC(phone2, line2, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName1; + TName incomingCallName2; + + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData21(callId1, mobileService, + hangUpCause, + autoStChangeDisable); + TMockLtsyCallData2 mockData22(callId2, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData01(callId1, mobileService); + TMockLtsyCallData0 mockData02(callId2, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::HangUp + //------------------------------------------------------------------------- + + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call1); + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call2); + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData21.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + mockData01.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call1.HangUp(requestStatus1); + + expectData.Close(); + mockData22.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + completeData.Close(); + mockData02.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call2.HangUp(requestStatus2); + + User::WaitForRequest(requestStatus1); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + CleanupStack::PopAndDestroy(2); // call1, call2 + CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, expectData, completeData, this + // line1, line2 + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CHU-00015 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RCall::HangUp with timeout for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RCall::HangUp and tests for timeout for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHangUp00015L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName incomingCallName; + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::HangUp + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call.HangUp(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ERR_PRINTF2(_L("$CTSYKnownFailure: defect id = %d"), 100303); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CH-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Hold for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Hold for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHold0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallHold, expectData, KErrNotSupported); + call.Hold(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallHold, expectData); + iMockLTSY.CompleteL(EMobileCallHold, KErrGeneral, expectData); + call.Hold(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::Hold when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallHold, expectData); + iMockLTSY.CompleteL(EMobileCallHold, KErrNone, expectData); + call.Hold(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::Hold + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallHold, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(5, this); // expectData, completeData, call, line + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CH-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::Hold for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileCall::Hold for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHold0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test cancelling of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallHold, expectData); + iMockLTSY.CompleteL(EMobileCallHold, KErrNone, expectData); + + call.Hold(requestStatus); + + call.CancelAsyncRequest(EMobileCallHold); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + + //TSY has started a request and it is not possible to then cancel this + //request. The best thing for the TSY to do in this case is to proceed + //as though the Cancel never happened. The server's call to the TSY + //cancel function will return synchronously. The TSY then continues to + //wait for the original acknowledgement and when it receives it, + //the TSY will complete the original request. + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(mockLtsyStatus); + + CleanupStack::PopAndDestroy(4); // expectData, this, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CH-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::Hold for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileCall::Hold for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHold0004L() + { + + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RMobileCall call1; + CleanupClosePushL(call1); + + RMobileCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TName incomingCallName1; + + TInt callId2 = 2; + TName incomingCallName2; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData01(callId1, mobileService); + TMockLtsyCallData0 mockData02(callId2, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData01.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallHold, expectData); + iMockLTSY.CompleteL(EMobileCallHold, KErrNone, expectData); + + call1.Hold(requestStatus1); + + expectData.Close(); + mockData02.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallHold, expectData); + iMockLTSY.CompleteL(EMobileCallHold, KErrNone, expectData); + + call2.Hold(requestStatus2); + + User::WaitForRequest(requestStatus1); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + // Done ! + CleanupStack::PopAndDestroy(4); // line1, line2, call1, call2 + CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, expectData, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CH-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Hold with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Hold and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHold0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallHold, expectData); + call.Hold(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CH-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Hold for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Hold for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHold0006L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + call.Hold(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CH-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Hold for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Hold for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHold00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + call.Hold(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CH-0001a +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Hold and RMobileCall::AnswerIncomingCall fails because call waiting is disabled +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Hold for voice and data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestHold0001aL() + { + //Test voice call functionality + TInt ret = TestAnsweringFailsBecauseHoldDoesNotWorkL( KMmTsyVoice1LineName ); + ASSERT_EQUALS(KErrNone, ret); + + //Test data call functionality + ret = TestAnsweringFailsBecauseHoldDoesNotWorkL( KMmTsyDataLineName ); + ASSERT_EQUALS(KErrNone, ret); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CS-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Swap for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Swap for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestSwap0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallSwap, expectData, KErrNotSupported); + call.Swap(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallSwap, expectData); + iMockLTSY.CompleteL(EMobileCallSwap, KErrGeneral, expectData); + call.Swap(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::Swap when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallSwap, expectData); + iMockLTSY.CompleteL(EMobileCallSwap, KErrNone, expectData); + call.Swap(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::Swap + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallSwap, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(5, this); // expectData, completeData, call, line + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CS-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::Swap for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileCall::Swap for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestSwap0002L() + { + +// This test should test cancellation of Swap +// If this API does not have a cancel, the test step should be completely removed. + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test cancelling of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + + iMockLTSY.ExpectL(EMobileCallSwap, expectData); + iMockLTSY.CompleteL(EMobileCallSwap, KErrNone, expectData); + + call.Swap(requestStatus); + + call.CancelAsyncRequest(EMobileCallSwap); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + // see CMmVoiceCallTsy::CancelService in line 508 in file CMmVoiceCallTsy.cpp + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(mockLtsyStatus); + + CleanupStack::PopAndDestroy(4); // expectData, this, call, line + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CS-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::Swap for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileCall::Swap for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestSwap0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RMobileCall call1; + CleanupClosePushL(call1); + + RMobileCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TName incomingCallName1; + + TInt callId2 = 2; + TName incomingCallName2; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData01(callId1, mobileService); + expectData.Close(); + mockData01.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallSwap, expectData); + iMockLTSY.CompleteL(EMobileCallSwap, KErrNone, expectData); + + call1.Swap(requestStatus1); + + TMockLtsyCallData0 mockData02(callId2, mobileService); + expectData.Close(); + mockData02.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallSwap, expectData); + iMockLTSY.CompleteL(EMobileCallSwap, KErrNone, expectData); + + call2.Swap(requestStatus2); + + User::WaitForRequest(requestStatus1); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + // Done ! + CleanupStack::PopAndDestroy(4); // line1, line2, call1, call2 + CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, expectData, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CS-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Swap with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Swap and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestSwap0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileCall::Swap + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallSwap, expectData); + + call.Swap(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CS-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Swap for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Swap for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestSwap0006L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for data + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + // see line 252 in function CMmDataCallTsy::DoExtFuncL in file CMmDataCallTsy.cpp + call.Swap(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CS-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Swap for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Swap for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestSwap00011L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for data + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + // see line 265 in function CMmFaxCallTsy::DoExtFuncL in file CMmFaxCallTsy.cpp + call.Swap(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CR-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Resume for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Resume for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestResume0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallResume, expectData, KErrNotSupported); + call.Resume(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallResume, expectData); + iMockLTSY.CompleteL(EMobileCallResume, KErrGeneral, expectData); + call.Resume(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::Resume when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallResume, expectData); + iMockLTSY.CompleteL(EMobileCallResume, KErrNone, expectData); + call.Resume(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::Resume + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallResume, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(5, this); // expectData, completeData, line, this, call + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CR-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::Resume for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileCall::Resume for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestResume0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test cancelling of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + + iMockLTSY.ExpectL(EMobileCallResume, expectData); + iMockLTSY.CompleteL(EMobileCallResume, KErrNone, expectData); + + call.Resume(requestStatus); + + call.CancelAsyncRequest(EMobileCallResume); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + // see CMmVoiceCallTsy::CancelService in line 507 in file CMmVoiceCallTsy.cpp + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(mockLtsyStatus); + + CleanupStack::PopAndDestroy(4); // expectData, this, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CR-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::Resume for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileCall::Resume for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestResume0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RMobileCall call1; + CleanupClosePushL(call1); + + RMobileCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TName incomingCallName1; + + TInt callId2 = 2; + TName incomingCallName2; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData01(callId1, mobileService); + expectData.Close(); + mockData01.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallResume, expectData); + iMockLTSY.CompleteL(EMobileCallResume, KErrNone, expectData); + + call1.Resume(requestStatus1); + + TMockLtsyCallData0 mockData02(callId2, mobileService); + expectData.Close(); + mockData02.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallResume, expectData); + iMockLTSY.CompleteL(EMobileCallResume, KErrNone, expectData); + + call2.Resume(requestStatus2); + + User::WaitForRequest(requestStatus1); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + // Done ! + CleanupStack::PopAndDestroy(4); // line1, line2, call1, call2 + CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, expectData, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CR-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Resume with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Resume and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestResume0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test A: Test timeout of RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallResume, expectData); + + call.Resume(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CR-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Resume for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Resume for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestResume0006L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for data + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + // see EMobileCallResume case in function CMmDataCallTsy::DoExtFuncL in file CMmDataCallTsy.cpp + call.Resume(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CR-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Resume for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Resume for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestResume00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for data + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + // see EMobileCallResume case in function CMmFaxCallTsy::DoExtFuncL in file CMmFaxCallTsy.cpp + call.Resume(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CDF-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Deflect for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Deflect for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDeflect0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for data + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test API is not supported + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + RMobileCall::TMobileCallDeflect deflectType = RMobileCall::EDeflectUnspecified; + RMobilePhone::TMobileAddress destination; + call.Deflect(requestStatus, deflectType, destination); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CDF-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Deflect for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Deflect for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDeflect0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for data + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test API is not supported + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + RMobileCall::TMobileCallDeflect deflectType = RMobileCall::EDeflectUnspecified; + RMobilePhone::TMobileAddress destination; + call.Deflect(requestStatus, deflectType, destination); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CDF-0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Deflect for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Deflect for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDeflect0003L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for data + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // Test API is not supported + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + RMobileCall::TMobileCallDeflect deflectType = RMobileCall::EDeflectUnspecified; + RMobilePhone::TMobileAddress destination; + call.Deflect(requestStatus, deflectType, destination); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4); // expectData, call, line + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CT-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Transfer for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Transfer for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTransfer0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + RMobileCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + TInt callId(1); + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus requestNotify; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; //RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusHold; + callId = 2; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallTransfer, expectData, KErrNotSupported); + + call.Transfer(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallTransfer, expectData); + iMockLTSY.CompleteL(EMobileCallTransfer, KErrGeneral, expectData); + call.Transfer(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::Transfer when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallTransfer, expectData); + iMockLTSY.CompleteL(EMobileCallTransfer, KErrNone, expectData); + call.Transfer(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::Transfer + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallTransfer, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // expectData, completeData, call, line, call2 + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CT-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::Transfer for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileCall::Transfer for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTransfer0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + RMobileCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusHold; + callId = 2; + + //------------------------------------------------------------------------- + // Test cancelling of RMobileCall::Transfer + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + + iMockLTSY.ExpectL(EMobileCallTransfer, expectData); + iMockLTSY.CompleteL(EMobileCallTransfer, KErrNone, expectData); + + call.Transfer(requestStatus); + + call.CancelAsyncRequest(EMobileCallTransfer); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + // see CMmVoiceCallTsy::CancelService in file CMmVoiceCallTsy.cpp + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(mockLtsyStatus); + + CleanupStack::PopAndDestroy(5); // expectData, this, call, line, call2 + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CT-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::Transfer for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileCall::Transfer for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTransfer0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(telServer2,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line11; + RLine line12; + RLine line22; + + RMobileCall call11; + CleanupClosePushL(call11); + + RMobileCall call12; + CleanupClosePushL(call12); + + RMobileCall call22; + CleanupClosePushL(call22); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TInt callId2 = 2; + TName incomingCallName1; + TName incomingCallName2; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + TRequestStatus mockLtsyStatus; + + // open new line11 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line11, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line12 for KMmTsyVoice2LineName + errorCode = OpenNewLineLC(iPhone, line12, KMmTsyVoice2LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line22 for KMmTsyVoice2LineName + errorCode = OpenNewLineLC(phone2, line22, KMmTsyVoice2LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line11, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call11.OpenExistingCall(line11, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusHold; + mobileService = RMobilePhone::EAuxVoiceService; + //------------------------------------------------------------------------- + // create new incoming call12 for iPhone + errorCode = CreateIncomingCallL(line12, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call12.OpenExistingCall(line12, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + RLine::TCallInfo callInfo22; + errorCode = line22.GetCallInfo(0, callInfo22); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call22.OpenExistingCall(line22, callInfo22.iCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileCall::Transfer + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData(callId2, mobileService); + expectData.Close(); + mockData.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallTransfer, expectData); + iMockLTSY.CompleteL(EMobileCallTransfer, KErrNone, expectData, 10); + + call12.Transfer(requestStatus1); + call22.Transfer(requestStatus2); + + User::WaitForRequest(requestStatus1); + User::WaitForRequest(requestStatus2); + + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(6); // line11, line12, line22, call11, call12, call22 + CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, expectData, this, completeData + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CT-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Transfer with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Transfer and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTransfer0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + + RMobileCall call; + CleanupClosePushL(call); + + RMobileCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileCall::Transfer + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusHold; + callId = 2; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallTransfer, expectData); + + call.Transfer(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + CleanupStack::PopAndDestroy(5, this); // expectData, this, line, call, call2 + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CT-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Transfer for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Transfer for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTransfer0006L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + RMobileCall ringingCall; + CleanupClosePushL(ringingCall); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus requestNotify; + + // open new line and call for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = ringingCall.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + callId = 2; + mobileCallStatus = RMobileCall::EStatusHold; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + call.Transfer(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, RMobilePhone::ECircuitDataService); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::Transfer + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallTransfer, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(6, this); // expectData, completeData, call, line, ringingCall + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CT-0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::Transfer for data calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileCall::Transfer for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTransfer0009L() + { + + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RMobileCall call1; + CleanupClosePushL(call1); + RMobileCall call2; + CleanupClosePushL(call2); + RMobileCall call3; + CleanupClosePushL(call3); + RMobileCall call4; + CleanupClosePushL(call4); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TInt callId2 = 2; + TInt callId3 = 3; + TInt callId4 = 4; + TName incomingCallName1; + TName incomingCallName2; + TName incomingCallName3; + TName incomingCallName4; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 for KMmTsyDataLineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatusHold = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + //------------------------------------------------------------------------- + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatusHold); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 for phone2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatusHold); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileCall::Transfer + //------------------------------------------------------------------------- + + mobileCallStatusHold = RMobileCall::EStatusHold; + + //------------------------------------------------------------------------- + // create new incoming call1 for iPhone + errorCode = CreateIncomingCallL(line1, callId3, incomingCallName3, + mobileService, mobileCallStatusHold); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call3.OpenExistingCall(line1, incomingCallName3); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + errorCode = CreateIncomingCallL(line2, callId4, incomingCallName4, + mobileService, mobileCallStatusHold); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call4.OpenExistingCall(line2, incomingCallName4); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + call3.Transfer(requestStatus1); + call4.Transfer(requestStatus2); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus2.Int()); + + // Done ! + CleanupStack::PopAndDestroy(6); // line1, line2, call1, call2, call3, call4 + CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, expectData, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CT-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::Transfer for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::Transfer for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTransfer00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + RMobileCall ringingCall; + CleanupClosePushL(ringingCall); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus requestNotify; + + // open new line and call for KMmTsyFaxLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = ringingCall.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusHold; + callId = 2; + + /* + * Can't create incoming call with call status equal RMobileCall::EStatusHold. + * Destructor of CMmCallTsy is called for inclomming call (callId = 1) + * with call status equal RMobileCall::EStatusRinging by call of RCall::Close(). + */ + +// ERR_PRINTF2(_L("$CTSYKnownFailure: defect id = %d"), 100804); + + //ASSERT_TRUE(false); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + call.Transfer(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // expectData, completeData, call, line, ringingCall + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-MTAC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobilePhone::TerminateAllCalls +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::TerminateAllCalls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTerminateAllCalls0001L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); // PUSH + + TRequestStatus requestStatus; + + //----------------------------------------------------------------------- + // TEST 0: with no active calls (request should not reach the LTSY) + //---------------------------------------------------------------------- + + iPhone.TerminateAllCalls(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new line and call for KMmTsyVoice1LineName + RLine line; + RCall call; + TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH + ASSERT_EQUALS(KErrNone, errorCode); + + // create new incoming call + TName incomingCallName; + TInt callId = 1; + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + RMobilePhone::EVoiceService, RMobileCall::EStatusConnecting); + + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); // PUSH + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyData1 mockData(callId); + mockData.SerialiseL(expectData); + iMockLTSY.ExpectL(ECtsyPhoneTerminateAllCallsReq, expectData, KErrNotSupported); + iPhone.TerminateAllCalls(requestStatus); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + AssertMockLtsyStatusL(); + + + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + iMockLTSY.ExpectL(ECtsyPhoneTerminateAllCallsReq, expectData); + iMockLTSY.CompleteL(ECtsyPhoneTerminateAllCallsComp, KErrGeneral); + + iPhone.TerminateAllCalls(requestStatus); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobilePhone::TerminateAllCalls. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(ECtsyPhoneTerminateAllCallsReq, expectData); + iMockLTSY.CompleteL(ECtsyPhoneTerminateAllCallsComp, KErrNone); + + iPhone.TerminateAllCalls(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobilePhone::TerminateAllCalls + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(ECtsyPhoneTerminateAllCallsComp, KErrNone); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-MTAC-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling RMobilePhone::TerminateAllCalls +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::TerminateAllCalls and cancels it +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTerminateAllCalls0002L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); // PUSH + + //------------------------------------------------------------------------- + + // open new line and call for KMmTsyVoice1LineName + RLine line; + RCall call; + TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH + ASSERT_EQUALS(KErrNone, errorCode); + + // create new incoming call + TName incomingCallName; + TInt callId = 1; + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + RMobilePhone::EVoiceService, RMobileCall::EStatusConnecting); + + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); // PUSH + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // Test A: cancelling of RMobilePhone::TerminateAllCalls + //------------------------------------------------------------------------- + + TMockLtsyData1 mockData(callId); + mockData.SerialiseL(expectData); + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + // Expect call down to LTSY for this IPC + iMockLTSY.ExpectL(ECtsyPhoneTerminateAllCallsReq, expectData); + + // Queue response to be delayed to give time for cancel to come through + iMockLTSY.CompleteL(ECtsyPhoneTerminateAllCallsComp, KErrNone, 10); + + TRequestStatus requestStatus; + iPhone.TerminateAllCalls(requestStatus); + iPhone.CancelAsyncRequest(EMobilePhoneTerminateAllCalls); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + AssertMockLtsyStatusL(); + + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-MTAC-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests of RMobilePhone::TerminateAllCalls +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::TerminateAllCalls on multiple clients +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTerminateAllCalls0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + // + // set up line and call for first client + + RLine line; + RCall call; + TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH + ASSERT_EQUALS(KErrNone, errorCode); + + // create new incoming call + TName incomingCallName; + TInt callId = 1; + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + RMobilePhone::EVoiceService, RMobileCall::EStatusConnecting); + + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); // PUSH + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + + // + // set up call for second client + + RLine line2; + RCall call2; + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); // PUSH + ASSERT_EQUALS(KErrNone, errorCode); + + // create new incoming call + TName incomingCallName2; + TInt callId2 = 2; + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + RMobilePhone::EVoiceService, RMobileCall::EStatusConnecting); + + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call2); // PUSH + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + + // let's start testing... + + RBuf8 expectData; + CleanupClosePushL(expectData); // PUSH + TMockLtsyData1 mockData(callId); + mockData.SerialiseL(expectData); + + //RBuf8 expectData2; + //CleanupClosePushL(expectData2); // PUSH + //TMockLtsyData1 mockData2(callId2); + //mockData2.SerialiseL(expectData2); + + iMockLTSY.ExpectL(ECtsyPhoneTerminateAllCallsReq, expectData); + iMockLTSY.CompleteL(ECtsyPhoneTerminateAllCallsComp, KErrNone, 20); + TRequestStatus requestStatus; + TRequestStatus requestStatus2; + iPhone.TerminateAllCalls(requestStatus); + phone2.TerminateAllCalls(requestStatus2); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(8, this); // expectData, + // call2, line2, call, line, + // phone2, telServer2, this + } + +/** +@SYMTestCaseID BA-CTSY-CCON-MTAC-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobilePhone::TerminateAllCalls with timeout. +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::TerminateAllCalls and tests for timeout. +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestTerminateAllCalls0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); // PUSH + + + // open new line and call for KMmTsyVoice1LineName + RLine line; + RCall call; + TInt errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); // PUSH + ASSERT_EQUALS(KErrNone, errorCode); + + + // create new incoming call + TName incomingCallName; + TInt callId = 1; + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + RMobilePhone::EVoiceService, RMobileCall::EStatusConnecting); + + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupClosePushL(call); // PUSH + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + TMockLtsyData1 mockData(callId); + mockData.SerialiseL(expectData); + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobilePhone::TerminateAllCalls + //------------------------------------------------------------------------- + + TRequestStatus requestStatus; + iMockLTSY.ExpectL(ECtsyPhoneTerminateAllCallsReq, expectData); + iPhone.TerminateAllCalls(requestStatus); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // call, line, expectData, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-MSICT-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetIncomingCallType +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::SetIncomingCallType +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestSetIncomingCallType0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + + RMobilePhone::TMobilePhoneIncomingCallType callType = RMobilePhone::EIncomingTypeNotSpecified; + + RMobileCall::TMobileDataCallParamsV1 dataCallParamsV1; + TPckg dataCallParamsV1Pckg(dataCallParamsV1); + + //------------------------------------------------------------------------- + // Test API is not supported + //------------------------------------------------------------------------- + + iPhone.SetIncomingCallType(requestStatus, callType, dataCallParamsV1Pckg); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1, this); // this + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAICI-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::AnswerIncomingCallISV for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::AnswerIncomingCallISV for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCallISV0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + TRequestStatus requestStatus; + TRequestStatus requestNotify; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams; + TPckg callParamsPckg(callParams); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData, KErrNotSupported); + call.AnswerIncomingCallISV(requestStatus, callParamsPckg); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData); + iMockLTSY.CompleteL(EMobileCallAnswerISV, KErrGeneral, expectData); + call.AnswerIncomingCallISV(requestStatus, callParamsPckg); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::AnswerIncomingCallISV when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData); + iMockLTSY.CompleteL(EMobileCallAnswerISV, KErrNone, expectData); + call.AnswerIncomingCallISV(requestStatus, callParamsPckg); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // close incoming call + CloseIncomingCallL(call, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::AnswerIncomingCallISV + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallAnswerISV, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST to increase coverage + //------------------------------------------------------------------------- + + RMobileCall call2; + CleanupClosePushL(call2); + TRequestStatus requestStatus2; + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + errorCode = call2.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData); + iMockLTSY.CompleteL(EMobileCallAnswerISV, KErrNone, expectData); + call.AnswerIncomingCallISV(requestStatus, callParamsPckg); + + call2.AnswerIncomingCallISV(requestStatus2, callParamsPckg); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); + + call.Close(); + CloseIncomingCallL(call2, callId, mobileService); + + //------------------------------------------------------------------------- + // TEST : to increase CMmVoiceCallTsy::AnswerIncomingCall coverage + // covers "else if( activeCall && + // ( !( KETelExt3rdPartyV1 == activeCall->GetExtensionId() ) && + // ( KETelExt3rdPartyV1 == extensionId ) ) )" condition + //------------------------------------------------------------------------- + + mobileCallStatus = RMobileCall::EStatusConnected; + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + call.AnswerIncomingCallISV(requestStatus, callParamsPckg); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // expectData, completeData, call, line, call2 + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAICI-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::AnswerIncomingCallISV for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileCall::AnswerIncomingCallISV for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCallISV0002L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + TMockLtsyCallData0 mockData0(callId, mobileService); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams; + TPckg callParamsPckg(callParams); + + //------------------------------------------------------------------------- + // Test cancelling of RCall::AnswerIncomingCallISV + //------------------------------------------------------------------------- + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData); + + call.AnswerIncomingCallISV(requestStatus, callParamsPckg); + + TInt hangUpCause = KErrGsmBusyUserRequest; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData2(callId, mobileService, + hangUpCause, + autoStChangeDisable); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData); + + call.CancelAsyncRequest(EMobileCallAnswerISV); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrCancel, requestStatus.Int()); + + User::WaitForRequest(mockLtsyStatus); + + CleanupStack::PopAndDestroy(5); // expectData, completeData, this, call, line + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAICI-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::AnswerIncomingCallISV for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileCall::AnswerIncomingCallISV for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCallISV0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + // Open second client + RTelServer telServer2; + TInt ret = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + RMobileCall call1; + CleanupClosePushL(call1); + + RMobileCall call2; + CleanupClosePushL(call2); + + TInt errorCode = KErrNone; + + TInt callId1 = 1; + TName incomingCallName1; + + TInt callId2 = 2; + TName incomingCallName2; + + TRequestStatus requestStatus1; + TRequestStatus requestStatus2; + + // open new line1 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line1, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + // open new line2 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RCall::AnswerIncomingCall + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call1 + errorCode = CreateIncomingCallL(line1, callId1, incomingCallName1, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call1.OpenExistingCall(line1, incomingCallName1); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call2 + errorCode = CreateIncomingCallL(line2, callId2, incomingCallName2, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, incomingCallName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData01(callId1, mobileService); + expectData.Close(); + mockData01.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData); + iMockLTSY.CompleteL(EMobileCallAnswerISV, KErrNone, expectData); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call1.AnswerIncomingCallISV(requestStatus1, mmParamsPckgV1); + + TMockLtsyCallData0 mockData02(callId2, mobileService); + expectData.Close(); + mockData02.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData); + iMockLTSY.CompleteL(EMobileCallAnswerISV, KErrNone, expectData); + + call2.AnswerIncomingCallISV(requestStatus2, mmParamsPckgV1); + + User::WaitForRequest(requestStatus1); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus1.Int()); + + User::WaitForRequest(requestStatus2); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus2.Int()); + + // Done ! + CleanupStack::PopAndDestroy(4); // line1, line2, call1, call2 + CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, expectData, this + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAICI-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::AnswerIncomingCallISV with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::AnswerIncomingCallISV and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCallISV0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileCall::AnswerIncomingCallISV + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + TMockLtsyCallData0 mockData0(callId, mobileService); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallAnswerISV, expectData); + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCallISV(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CAICI-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::AnswerIncomingCallISV for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::AnswerIncomingCallISV for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCallISV0006L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyDataLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call.AnswerIncomingCallISV(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, this, line, call + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CAICI-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::AnswerIncomingCallISV for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::AnswerIncomingCallISV for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestAnswerIncomingCallISV00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RLine line; + RMobileCall call; + CleanupClosePushL(call); + + TInt errorCode = KErrNone; + TInt callId = 1; + TName incomingCallName; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyFaxLineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + TMockLtsyCallData0 mockData0(callId, mobileService); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // create new incoming call + errorCode = CreateIncomingCallL(line, callId, incomingCallName, + mobileService, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + + errorCode = call.OpenExistingCall(line, incomingCallName); + ASSERT_EQUALS(KErrNone, errorCode); + //------------------------------------------------------------------------- + expectData.Close(); + mockData0.SerialiseL(expectData); + call.AnswerIncomingCallISV(requestStatus, mmParamsPckgV1); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, this, call, line + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CDI-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialISV for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::DialISV for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDialISV0001L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RMobileLine line; + RMobileCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyVoice1LineName + errorCode = line.Open(iPhone, KMmTsyVoice1LineName); + CleanupClosePushL(line); + ASSERT_EQUALS(KErrNone, errorCode); + + _LIT(KDoubleColon, "::"); + + TName name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(KMmTsyVoice1LineName); + name.Append(KDoubleColon); + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams; + callParams.iIdRestrict = RMobileCall::ESendMyId; + callParams.iAutoRedial = ETrue; + TPckg pckgCallParams(callParams); + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + RMmCustomAPI::TEmerNumberCheckMode emerNumberCheckMode; + emerNumberCheckMode.iCheckMode = RMmCustomAPI::EEmerNumberCheckNormal; + emerNumberCheckMode.iNumber.Copy(KPhoneNumber); + + RMmCustomAPI::TMobileTelNumber* telNumberPtr = NULL; + + TMockLtsyData1 expectLtsyData1(emerNumberCheckMode); + + TMockLtsyCallData2 + expectLtsyData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 completeLtsyData1(callId, mobileService); + + TMockLtsyData1< RMmCustomAPI::TMobileTelNumber* > completeLtsyData2(telNumberPtr); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RCall::Dial + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + completeLtsyData1.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallDialISV, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST A: Try to make RMobileCall::DialISV request in case where + // CustomTSY is not opened. This should fail because in DialISV case TSY + // checks dialling number type using CustomTSY. + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.DialISV(requestStatus, pckgCallParams, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::DialISV when result is not cached. + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // CustomTSY must be open before DialISV is requested + iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC); + + RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache; + currentlyRetrievedCache.iCacheId = 1; + currentlyRetrievedCache.iRecordId = 0; + TMockLtsyData1 ltsyData2(currentlyRetrievedCache); + expectData.Close(); + ltsyData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, expectData); + + RMmCustomAPI customAPI; + customAPI.Open(iPhone); + CleanupClosePushL(customAPI); + AssertMockLtsyStatusL(); + //------------------------------------------------------------------------- + + completeData.Close(); + completeLtsyData2.SerialiseL(completeData); + iMockLTSY.CompleteL(ECustomCheckEmergencyNumberIPC, KErrNone, completeData); + + expectData.Close(); + expectLtsyData1.SerialiseL(expectData); + iMockLTSY.ExpectL(ECustomCheckEmergencyNumberIPC, expectData); + + expectData.Close(); + expectLtsyData1.SerialiseL(expectData); + iMockLTSY.ExpectL(EMobileCallDialISV, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + completeLtsyData1.SerialiseL(completeData); + iMockLTSY.CompleteL(EMobileCallDialISV, KErrNone, completeData); + + call.DialISV(requestStatus, pckgCallParams, KPhoneNumber); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + call.Close(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // this, expectData, completeData, line, call, customAPI + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CDI-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialISV for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::DialISV for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDialISV0006L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RMobileLine line; + RMobileCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyDataLineName + errorCode = line.Open(iPhone, KMmTsyDataLineName); + CleanupClosePushL(line); + ASSERT_EQUALS(KErrNone, errorCode); + + _LIT(KDoubleColon, "::"); + + TName name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(KMmTsyDataLineName); + name.Append(KDoubleColon); + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams; + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + TPckg pckgCallParams(callParams); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.DialISV(requestStatus, pckgCallParams, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::DialISV + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallDialISV, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CDI-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialISV for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::DialISV for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDialISV00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RMobileLine line; + RMobileCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open new line for KMmTsyDataLineName + errorCode = line.Open(iPhone, KMmTsyFaxLineName); + CleanupClosePushL(line); + ASSERT_EQUALS(KErrNone, errorCode); + + _LIT(KDoubleColon, "::"); + + TName name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(KMmTsyFaxLineName); + name.Append(KDoubleColon); + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + + RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams; + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + TPckg pckgCallParams(callParams); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.DialISV(requestStatus, pckgCallParams, KPhoneNumber); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::DialISV + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallDialISV, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line + + } + + +/** +@SYMTestCaseID BA-CTSY-CCON-CDCC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialCallControl for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::DialCallControl for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDialCallControl0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RMobileLine line; + RMobileCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // Open new line for KMmTsyVoice1LineName + errorCode = line.Open(iPhone, KMmTsyVoice1LineName); + CleanupClosePushL(line); + ASSERT_EQUALS(KErrNone, errorCode); + + _LIT(KDoubleColon, "::"); + + TName name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(KMmTsyVoice1LineName); + name.Append(KDoubleColon); + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV7 callParams; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + TPckg pckgCallParams(callParams); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // Open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.DialCallControl(requestStatus, pckgCallParams, KPhoneNumber); + User::WaitForRequest(requestStatus); + + // This is not a defect. DialCallControl fails because feature is not + // supported by CTSY. + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // call + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::DialCallControl + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallDialCallControl, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CDCC-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialCallControl for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::DialCallControl for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDialCallControl0006L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RMobileLine line; + RMobileCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // Open new line for KMmTsyDataLineName + errorCode = line.Open(iPhone, KMmTsyDataLineName); + CleanupClosePushL(line); + ASSERT_EQUALS(KErrNone, errorCode); + + _LIT(KDoubleColon, "::"); + + TName name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(KMmTsyDataLineName); + name.Append(KDoubleColon); + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService; + + RMobileCall::TMobileCallParamsV7 callParams; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + TPckg pckgCallParams(callParams); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // Open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.DialCallControl(requestStatus, pckgCallParams, KPhoneNumber); + User::WaitForRequest(requestStatus); + + // This is not a defect. DialCallControl fails because feature is not + // supported by CTSY. + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // call + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::DialISV + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallDialCallControl, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, call + + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CDCC-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialCallControl for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::DialCallControl for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestDialCallControl00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RMobileLine line; + RMobileCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // Open new line for KMmTsyFaxLineName + errorCode = line.Open(iPhone, KMmTsyFaxLineName); + CleanupClosePushL(line); + ASSERT_EQUALS(KErrNone, errorCode); + + _LIT(KDoubleColon, "::"); + + TName name; + name = KMmTsyPhoneName; + name.Append(KDoubleColon); + name.Append(KMmTsyFaxLineName); + name.Append(KDoubleColon); + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService; + + RMobileCall::TMobileCallParamsV7 callParams; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + TPckg pckgCallParams(callParams); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // Open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + call.DialCallControl(requestStatus, pckgCallParams, KPhoneNumber); + User::WaitForRequest(requestStatus); + + // This is not a defect. DialCallControl fails because feature is not + // supported by CTSY. + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + call.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); //call + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::DialISV + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + expectData.Close(); + mockData0.SerialiseL(expectData); + iMockLTSY.CompleteL(EMobileCallDialCallControl, KErrNone, expectData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expectData, completeData, line, this + } + +/* + * Test case where answering fails because automatic hold does not work. + * + * @param aLineName Line name + * @return KErrNone if successful, otherwise another of the system-wide error + */ +TInt CCTsyCallControlFU::TestAnsweringFailsBecauseHoldDoesNotWorkL( const TDesC& aLineName ) + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RMobilePhone phone2; + TInt ret = phone2.Open(iTelServer,KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, ret); + CleanupClosePushL(phone2); + + RLine line1; + RLine line2; + + //Open new line1 for aLineName + TInt errorCode = OpenNewLineLC(iPhone, line1, aLineName); + ASSERT_EQUALS(KErrNone, errorCode); + + //Open new line2 for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(phone2, line2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + RMobileCall call1; + CleanupClosePushL(call1); + + RMobileCall call2; + CleanupClosePushL(call2); + + _LIT(KPhoneNumber, "101632960000"); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging; + RMobilePhone::TMobileService mobileService1; + RMobilePhone::TMobileService mobileService2 = RMobilePhone::EVoiceService; + + TInt callId1 = 1; + TName callName1; + + TInt callId2 = 2; + TName callName2; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + //------------------------------------------------------------------------- + // Create first call outgoing voice or data call + + errorCode = call1.OpenNewCall(line1, callName1); + ASSERT_EQUALS(KErrNone, errorCode); + + if ( !aLineName.Compare( KMmTsyDataLineName ) ) + { + //Dial data call + mobileService1 = RMobilePhone::ECircuitDataService; + + CallGetMobileCallInfoL(callId1, mobileService1, KPhoneNumber); + + RMobileCall::TMobileDataCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService1; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating ; + + TMockLtsyCallData2 + mockData0(0, mobileService1, callParams, callInfo); + + TPckg pckgCallParams(callParams); + + mockData0.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNone); + + call1.Dial(requestStatus, pckgCallParams, KPhoneNumber); + } + else + { + //Dial voice call + mobileService1 = RMobilePhone::EVoiceService; + + CallGetMobileCallInfoL(callId1, mobileService1, KPhoneNumber); + + RMobileCall::TMobileCallParamsV1 callParams; + callParams.iInterval = 4; + callParams.iCug.iCugIndex = 0xFFFF; + TPckg pckgCallParams(callParams); + + RMobileCall::TMobileCallInfoV8 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + callInfo.iService = mobileService1; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + + TMockLtsyCallData2 + mockData1(0, mobileService1, callParams, callInfo); + + mockData1.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNone); + + call1.Dial(requestStatus, pckgCallParams, KPhoneNumber); + } + + //Change call1 status to connected + mobileCallStatus = RMobileCall::EStatusDialling; + TMockLtsyCallData1 mockData2(callId1, mobileService1, mobileCallStatus); + completeData.Close(); + mockData2.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + mobileCallStatus = RMobileCall::EStatusConnecting; + TMockLtsyCallData1 mockData3(callId1, mobileService1, mobileCallStatus); + completeData.Close(); + mockData3.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + mobileCallStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 mockData4(callId1, mobileService1, mobileCallStatus); + completeData.Close(); + mockData4.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + if ( !aLineName.Compare( KMmTsyDataLineName ) ) + { + //Dial request for voice call is completed automatically by CTSY when call goes to connected state + //Complete here data call Dial. + TMockLtsyCallData0 mockData5(callId1, mobileService1); + mockData5.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + } + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + //Check that call1 is active + call1.GetMobileCallStatus(mobileCallStatus); + ASSERT_EQUALS(RMobileCall::EStatusConnected, mobileCallStatus); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + + + //------------------------------------------------------------------------- + // Create second incoming voice call. + + mobileCallStatus = RMobileCall::EStatusRinging; + errorCode = CreateIncomingCallL(line2, callId2, callName2, + mobileService2, mobileCallStatus); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + errorCode = call2.OpenExistingCall(line2, callName2); + ASSERT_EQUALS(KErrNone, errorCode); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // TEST A: AnswerIncomingCall for call2 is completed with error KErrMMEtelCallForbidden + // because automatic hold for call1 fails. + //------------------------------------------------------------------------- + + //There is now one active call and one ringing call. Cellular software sets + //active call1 to hold automatically when ringing call is answered. Normally this operation + //succeeds. In DoCoMo network hold operation fails in this situation if call waiting is + //disabled. + + //Background: Incoming call indication should not come from network if there is already an active call + //and call waiting is disabled. However in DoCoMo network incoming call indication comes + //through but answering to this call fails because hold operation for active call does not work. + + //Expected functionality: In this case CTSY should complete AnswerIncomingCall request with + //error and active call should stay in active state. + + TMockLtsyCallData0 mockData6(callId2, mobileService2); + expectData.Close(); + mockData6.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallAnswer, expectData); + + RMobileCall::TMobileCallParamsV1 callParamsV1; + TPckg mmParamsPckgV1(callParamsV1); + call2.AnswerIncomingCall(requestStatus, mmParamsPckgV1); + + //Incoming call goes to answering state. + mobileCallStatus = RMobileCall::EStatusAnswering; + TMockLtsyCallData1 mockData7(callId2, mobileService2, mobileCallStatus); + completeData.Close(); + mockData7.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + + //Network rejects hold operation for active call. + mobileCallStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 mockData8(callId1, mobileService1, mobileCallStatus); + completeData.Close(); + mockData8.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrMMEtelCallForbidden, completeData); + + //AnswerIncomingCall should be completed with error. + User::WaitForRequest(requestStatus); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrMMEtelCallForbidden, requestStatus.Int()); + AssertMockLtsyStatusL(); + + //Check that call1 is still in active state. + call1.GetMobileCallStatus(mobileCallStatus); + ASSERT_EQUALS(RMobileCall::EStatusConnected, mobileCallStatus); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // Hangup calls + + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData9(callId2, mobileService2, hangUpCause, autoStChangeDisable); + expectData.Close(); + mockData9.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call2.HangUp(requestStatus); + + //Change call2 status to disconnecting + mobileCallStatus = RMobileCall::EStatusDisconnecting; + TMockLtsyCallData1 mockData10(callId2, mobileService2, mobileCallStatus); + completeData.Close(); + mockData10.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //Change call2 status to idle + mobileCallStatus = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockData11(callId2, mobileService2, mobileCallStatus); + completeData.Close(); + mockData11.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //HangUp complete for call2 + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // Only the voice line is needing this flag. + if ( !aLineName.Compare( KMmTsyDataLineName ) ) + { + autoStChangeDisable = EFalse; + } + else + { + autoStChangeDisable = ETrue; + } + + TMockLtsyCallData2 mockData12(callId1, mobileService1, hangUpCause, autoStChangeDisable); + expectData.Close(); + mockData12.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + call1.HangUp(requestStatus); + + //Change call1 status to disconnecting + mobileCallStatus = RMobileCall::EStatusDisconnecting; + TMockLtsyCallData1 mockData13(callId1, mobileService1, mobileCallStatus); + completeData.Close(); + mockData13.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //Change call1 status to idle + mobileCallStatus = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockData14(callId1, mobileService1, mobileCallStatus); + completeData.Close(); + mockData14.SerialiseL(completeData); + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + + // when call becomes idle, remaining duration of the call is added to life time param in LTSY: + TUint32 duration2 = 4; // this is a dummy value, which won't be checked by mocksy engine + TMockLtsyData1 ltsyData2( duration2 ); + expectData.Close(); + ltsyData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, expectData); + + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //HangUp complete for call1 + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + //------------------------------------------------------------------------- + + // Done ! + CleanupStack::PopAndDestroy(8, this); // call2, call1, line2, line1, phone2, + // completeData, expectData, this + return KErrNone; + } + +/* + * Opens a phone subsession by name. + * + * @param aPhone The phone from which the line is to be opened. + * @param On return, contains the new line. + * @param aName The name of the phone to be opened + * @return KErrNone if successful, otherwise another of the system-wide error + */ + +TInt CCTsyCallControlFU::OpenNewLineLC(RMobilePhone& aPhone, RLine& aLine, const TDesC& aLineName) + { + TInt errorCode = KErrNone; + + // Open new line + errorCode = aLine.Open(aPhone, aLineName); + CleanupClosePushL(aLine); + + return errorCode; + } + +/* + * This function creates an incomming call for line and returns a name of call. + * + * @param aLine The line from which the call is to be created. + * @param aCallId ID of call. + * @param aIncomingCallName On return, contains the new name of incomming call. + * @param aMobileService Applicability of request to a mobile service group. + * @param aMobileCallStatus Describes the possible call states. + * @return KErrNone if successful, otherwise another of the system-wide error + */ + +TInt CCTsyCallControlFU::CreateIncomingCallL(RLine& aLine, + const TInt aCallId, + TName& aIncomingCallName, + RMobilePhone::TMobileService aMobileService, + RMobileCall::TMobileCallStatus aMobileCallStatus) + { + RBuf8 completeData; + + TRequestStatus requestNotify; + TRequestStatus mockLtsyStatus; + + //------------------------------------------------------------------------- + // call CMmVoiceLineTsy::CompleteNotifyIncomingCall for set iCallId > 0. + + aLine.NotifyIncomingCall(requestNotify, aIncomingCallName); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + RMobileCall::TMobileCallInfoV1 mobileCallInfo; + TMockLtsyCallData1 mockCallData1(aCallId, aMobileService, mobileCallInfo); + CleanupClosePushL(completeData); + mockCallData1.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(requestNotify); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestNotify.Int()); + + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + // call CMmVoiceCallTsy::CompleteNotifyStatusChange for set + // iMobileCallStatus = RMobileCall::EStatusRinging. + TMockLtsyCallData1 mockCallData2(aCallId, aMobileService, aMobileCallStatus); + completeData.Close(); + mockCallData2.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + //------------------------------------------------------------------------- + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); // completeData + + return KErrNone; + } + +/* + * This function closes an incomming call by aCallId. + * + * @param aCall The incomming call which is to be closed. + * @param aCallId ID of call. + * @param aMobileService Applicability of request to a mobile service group. + */ + +void CCTsyCallControlFU::CloseIncomingCallL(RCall& aCall, const TInt aCallId, + RMobilePhone::TMobileService aMobileService) + { + RBuf8 expectData; + CleanupClosePushL(expectData); + + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = EFalse; + TMockLtsyCallData2 mockData2(aCallId, aMobileService, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + aCall.Close(); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(1); // expectData + } + +// ExpectL and CopmleteL must precede this function. +void CCTsyCallControlFU::CallGetMobileCallInfoL(TInt aCallId, + RMobilePhone::TMobileService aService, + const TDesC &aTelNumber) + { + _LIT(KNullDesC , ""); + + RBuf8 data; + CleanupClosePushL(data); + + RMobileCall::TMobileCallInfoV1 callInfo; + callInfo.iDialledParty.iTelNumber.Copy(aTelNumber); + callInfo.iService = aService; + callInfo.iEmergency = EFalse; + callInfo.iRemoteParty.iCallingName = KNullDesC; + callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown; + callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNullDesC; + callInfo.iRemoteParty.iRemoteNumber.iNumberPlan = RMobilePhone::EUnknownNumberingPlan; + callInfo.iRemoteParty.iRemoteNumber.iTypeOfNumber = RMobilePhone::EUnknownNumber; + callInfo.iForwarded = EFalse; + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallRemoteParty; + + TMockLtsyCallData1 callInfoData(aCallId, aService, callInfo); + callInfoData.SerialiseL(data); + + iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data); + + CleanupStack::PopAndDestroy(1); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CEC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test increase coverage for RLine::EnumerateCall for voice +@SYMTestPriority High +@SYMTestActions Invokes RLine::EnumerateCall for voice +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestEnumerateCall0001L() + { + AuxEnumerateCallL(KMmTsyVoice1LineName); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CEC-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test increase coverage for RLine::EnumerateCall for data +@SYMTestPriority High +@SYMTestActions Invokes RLine::EnumerateCall for data +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestEnumerateCall0006L() + { + AuxEnumerateCallL(KMmTsyDataLineName); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CEC-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test increase coverage for RLine::EnumerateCall for fax +@SYMTestPriority High +@SYMTestActions Invokes RLine::EnumerateCall for fax +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestEnumerateCall00011L() + { + AuxEnumerateCallL(KMmTsyFaxLineName); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CNHC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test increase coverage for RLine::NotifyHookChange for voice +@SYMTestPriority High +@SYMTestActions Invokes RLine::NotifyHookChange for voice +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestNotifyHookChange0001L() + { + AuxNotifyHookChangeL(KMmTsyVoice1LineName); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CNHC-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test increase coverage for RLine::NotifyHookChange for data +@SYMTestPriority High +@SYMTestActions Invokes RLine::NotifyHookChange for data +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestNotifyHookChange0006L() + { + AuxNotifyHookChangeL(KMmTsyDataLineName); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CNHC-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test increase coverage for RLine::NotifyHookChange for fax +@SYMTestPriority High +@SYMTestActions Invokes RLine::NotifyHookChange for fax +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestNotifyHookChange00011L() + { + AuxNotifyHookChangeL(KMmTsyFaxLineName); + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CCNSC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test increase coverage for CMmLineTsy::CompleteNotifyStatusChange for voice +@SYMTestPriority High +@SYMTestActions Invokes CMmLineTsy::CompleteNotifyStatusChange for voice +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestCompleteNotifyStatusChange0001L() + { + AuxCompleteNotifyStatusChangeL(KMmTsyVoice1LineName); + } + +void CCTsyCallControlFU::AuxEnumerateCallL(const TDesC& aName) + { + + if (aName.Compare(KMmTsyVoice1LineName) != 0 && + aName.Compare(KMmTsyDataLineName) != 0 && + aName.Compare(KMmTsyFaxLineName) != 0) + return; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileLine line; + + // open new line for KMmTsyDataLineName + TInt errorCode = OpenNewLineLC(iPhone, line, aName); + ASSERT_EQUALS(KErrNone, errorCode); + + TInt index(0); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RLine::EnumerateCall when result is not cached. + //------------------------------------------------------------------------- + + errorCode = line.EnumerateCall(index); + ASSERT_EQUALS(KErrNone, errorCode); + + CleanupStack::PopAndDestroy(2, this); // line, this + } + +void CCTsyCallControlFU::AuxNotifyHookChangeL(const TDesC& aName) + { + + if (aName.Compare(KMmTsyVoice1LineName) != 0 && + aName.Compare(KMmTsyDataLineName) != 0 && + aName.Compare(KMmTsyFaxLineName) != 0) + return; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileLine line; + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RCall::THookStatus hookStatus; + + TInt errorCode = OpenNewLineLC(iPhone, line, aName); + ASSERT_EQUALS(KErrNone, errorCode); + + line.NotifyHookChange(requestStatus, hookStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + line.NotifyHookChangeCancel(); + + CleanupStack::PopAndDestroy(2, this); // line, this + } + +void CCTsyCallControlFU::AuxCompleteNotifyStatusChangeL(const TDesC& aName) + { + + RMobilePhone::TMobileService mobileService = RMobilePhone::EServiceUnspecified; + + if (aName.Compare(KMmTsyVoice1LineName) == 0) + { + mobileService = RMobilePhone::EVoiceService; + } + else if (aName.Compare(KMmTsyDataLineName) == 0) + { + mobileService = RMobilePhone::ECircuitDataService; + } + else if (aName.Compare(KMmTsyFaxLineName) == 0) + { + mobileService = RMobilePhone::EFaxService; + } + else + return; + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileLine line; + RCall call; + RMobileCall::TMobileCallStatus mobileCallStatus(RMobileCall::EStatusUnknown); + TName callName; + TInt callId(1); + RBuf8 completeData; + CleanupClosePushL(completeData); + + TRequestStatus mockLtsyStatus; + TRequestStatus requestNotify; + + TInt errorCode = OpenNewLineLC(iPhone, line, aName); + ASSERT_EQUALS(KErrNone, errorCode); + + //------------------------------------------------------------------------- + + line.NotifyIncomingCall(requestNotify, callName); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + RMobileCall::TMobileCallInfoV1 mobileCallInfo; + TMockLtsyCallData1 mockCallData1(callId, mobileService, mobileCallInfo); + mockCallData1.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(requestNotify); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestNotify.Int()); + + RArray arrayCallStatus; + CleanupClosePushL(arrayCallStatus); + + arrayCallStatus.AppendL(RMobileCall::EStatusDialling); + arrayCallStatus.AppendL(RMobileCall::EStatusAnswering); + arrayCallStatus.AppendL(RMobileCall::EStatusConnecting); + + for (TInt i = 0; i < arrayCallStatus.Count(); i++) + { + + mobileCallStatus = arrayCallStatus[i]; + + TMockLtsyCallData1 mockCallData2(callId, mobileService, mobileCallStatus); + completeData.Close(); + mockCallData2.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + } + + CleanupStack::PopAndDestroy(4, this); // line, this, completeName + // arrayCallStatus + } + +/** +@SYMTestCaseID BA-CTSY-CCON-CNUA-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test: generating a call with duration to update life time param of total call time +@SYMTestPriority High +@SYMTestActions Invokes updating life time param with every specified interval of sec elapsed + and with the reminder of time when call status becomes idle (in case of the conference call + it's the last call) +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyCallControlFU::TestUpdateLifeTime0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + RLine line; + RMobileCall call; + + TInt errorCode = KErrNone; + TRequestStatus requestStatus; + TRequestStatus requestStatus2; + TRequestStatus mockLtsyStatus; + + // open new line and call for KMmTsyVoice1LineName + errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode); + + TName name; + + // we are preparing to dial the call: + + _LIT(KPhoneNumber, "101632960000"); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + + RMobileCall::TMobileCallParamsV7 callParams; + RMobileCall::TMobileCallParamsV7Pckg pckgCallParams(callParams); + RMobileCall::TMobileCallInfoV8 callInfo; + callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callParams.iInterval = 100; + callParams.iWaitForDialTone = RCall::EDialToneWait; + callParams.iIdRestrict = RMobileCall::EIdRestrictDefault; + callParams.iCug.iExplicitInvoke = EFalse; + callParams.iCug.iCugIndex = 0xFFFF; + callParams.iCug.iSuppressPrefCug = EFalse; + callParams.iCug.iSuppressOA = EFalse; + callParams.iAutoRedial = EFalse; + + callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating; + callInfo.iService = mobileService; + callInfo.iStatus = RMobileCall::EStatusUnknown; + callInfo.iCallId =-1; + callInfo.iExitCode =0; + callInfo.iEmergency =0; + callInfo.iForwarded =0; + callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified; + callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified; + callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber); + + TMockLtsyCallData2 + mockData2(0, mobileService, callParams, callInfo); + + TMockLtsyCallData0 mockData0(callId, mobileService); + + RCall::TCallParams callDialParams; + TPckg pckgCallDialParams(callDialParams); + callDialParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier; + callDialParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow; + callDialParams.iInterval = 100; + callDialParams.iWaitForDialTone = RCall::EDialToneWait; + + // open new call + CleanupClosePushL(call); + errorCode = call.OpenNewCall(line, name); + ASSERT_EQUALS(KErrNone, errorCode); + + expectData.Close(); + mockData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallDial, expectData); + + CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber); + + completeData.Close(); + mockData0.SerialiseL(completeData); + iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData); + + // with a notifications we make sure the state of the call will become: connected + TRequestStatus reqState1, reqState2, reqState3; + RMobileCall::TMobileCallStatus status; + call.NotifyMobileCallStatusChange(reqState1, status); + + // we are dialing the call: + call.Dial(requestStatus, pckgCallDialParams, KPhoneNumber); + + RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusDialling; + TMockLtsyCallData1 mockCallData4(callId, mobileService, mobileCallStatus); + completeData.Close(); + mockCallData4.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(reqState1); + call.NotifyMobileCallStatusChange(reqState2, status); + + mobileCallStatus = RMobileCall::EStatusConnecting; + TMockLtsyCallData1 mockCallData5(callId, mobileService, mobileCallStatus); + completeData.Close(); + mockCallData5.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(reqState2); + call.NotifyMobileCallStatusChange(reqState3, status); + + mobileCallStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 mockCallData6(callId, mobileService, mobileCallStatus); + completeData.Close(); + mockCallData6.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // status call becomes 'connected' here... + + User::WaitForRequest(reqState3); + + // completion of the Dial() request: + User::WaitForRequest(requestStatus); + + // Here we will trigger call duration of 15sec. Timer interval causing update + // of life time parameter is set to 10 sec: so we will have a one update caused + // by firing timer. The remainding duration ~5sec will be triggered by + // the call status becoming idle. + TUint32 duration = 10; + TMockLtsyData1 ltsyData( duration ); + expectData.Close(); + ltsyData.SerialiseL(expectData); + // firing timer will cause this: + iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, expectData); + + // 15 sec call duration was chosen to trigger timer firing 1 update plus last update, + // when call becomes idle... + User::After(15000000); + + // completion of the timer firing event: + TRequestStatus mockLtsyStatus2; + iMockLTSY.NotifyTerminated(mockLtsyStatus2); + iMockLTSY.CompleteL(EMmTsyUpdateLifeTimeIPC, KErrNone); + + User::WaitForRequest(mockLtsyStatus2); + ASSERT_EQUALS(KErrNone, mockLtsyStatus2.Int()); + AssertMockLtsyStatusL(); + + // + + // preparing call state to become 'idle' eventually: + TRequestStatus notifyCallStatus; + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown; + call.NotifyMobileCallStatusChange(notifyCallStatus, callStatus); + + // hangup call is going to LTSY: + TInt hangUpCause = KErrGsmReleaseByUser; + TBool autoStChangeDisable = ETrue; + TMockLtsyCallData2 mockData3(callId, mobileService, + hangUpCause, + autoStChangeDisable); + expectData.Close(); + mockData3.SerialiseL(expectData); + iMockLTSY.ExpectL(EEtelCallHangUp, expectData); + + TRequestStatus hangupStatus; + call.HangUp(hangupStatus); //<--------- hang up triggers status changes + + callStatus = RMobileCall::EStatusDisconnecting; + TMockLtsyCallData1 mockCallData7(callId, mobileService, callStatus); + completeData.Close(); + mockCallData7.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(notifyCallStatus); + ASSERT_EQUALS(KErrNone, notifyCallStatus.Int()); + ASSERT_EQUALS(RMobileCall::EStatusDisconnecting, callStatus); // <------------disconnecting status + + call.NotifyMobileCallStatusChange(notifyCallStatus, callStatus); + + callStatus = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockCallData8(callId, mobileService, callStatus); + completeData.Close(); + mockCallData8.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData); + + // when call becomes idle, remaining duration of the call is added to life time param in LTSY: + TUint32 duration2 = 4; // this is a dummy value, which won't be checked by mocksy engine + TMockLtsyData1 ltsyData2( duration2 ); + expectData.Close(); + ltsyData2.SerialiseL(expectData); + iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, expectData); + + User::WaitForRequest(mockLtsyStatus); + // we did set a sleep time for 15sec, but after stopping timer it may give us 14 sec or 15 sec + // we can not determine the correct value for the mockLTSY; + // we tell mocksy engine to ignore duration param value + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(notifyCallStatus); + ASSERT_EQUALS(KErrNone, notifyCallStatus.Int()); + ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus); // <-------- idle status + + User::WaitForRequest(hangupStatus); + ASSERT_EQUALS(KErrNone, hangupStatus.Int()); // <--- then hang up is finished + + call.GetMobileCallStatus(callStatus); + ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus); + + // + + TRequestStatus mockLtsyStatus3; + iMockLTSY.NotifyTerminated(mockLtsyStatus3); + iMockLTSY.CompleteL(EMmTsyUpdateLifeTimeIPC, KErrNone); + + User::WaitForRequest(mockLtsyStatus3); + ASSERT_EQUALS(KErrNone, mockLtsyStatus3.Int()); + + call.Close(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(1); + CleanupStack::PopAndDestroy(4, this); + } + + +