diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/test/component/src/cctsyconferencecallcontrolfu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/test/component/src/cctsyconferencecallcontrolfu.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,4561 @@ +// 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 ConferenceCallControl in the Common TSY. +// +// + +/** + @file +*/ + +#include "cctsyconferencecallcontrolfu.h" +#include +#include +#include +#include +#include +#include "tmockltsydata.h" +#include +#include "cmmconferencecalltsy.h" +#include +#include + +CTestSuite* CCTsyConferenceCallControlFU::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGoOneToOne0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGoOneToOne0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGoOneToOne0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGoOneToOne0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGoOneToOne0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGoOneToOne00011L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestEnumerateCalls0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestCreateConference0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestCreateConference0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestCreateConference0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestCreateConference0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestBreakDownConference0001aL); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestBreakDownConference0001bL); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestBreakDownConference0001cL); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGhostConference0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyCapsChange0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyCapsChange0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyCapsChange0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGetConferenceStatus0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyConferenceEvent0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyConferenceEvent0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyConferenceEvent0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyConferenceStatusChange0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyConferenceStatusChange0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestNotifyConferenceStatusChange0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestSwap0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestSwap0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestSwap0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestSwap0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestHangUp0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestHangUp0001bL); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestHangUp0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestHangUp0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestHangUp0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestAddCall0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestAddCall0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestAddCall0003L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestAddCall0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestAddCall0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGetCaps0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGetMobileCallInfo0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyConferenceCallControlFU, TestGetMobileCallInfo0003L); + + END_SUITE; + } + + +// +// Actual test cases +// + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGOTO-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::GoOneToOne for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::GoOneToOne for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGoOneToOne0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RArray callsInConference; + CleanupClosePushL(callsInConference); + + // open new line for calls + RLine line; + OpenLineLC(line, KMmTsyVoice2LineName); + + // open 3d call + RMobileCall call3; + OpenNewCallLC(call3, line); + + //------------------------------------------------------------------------- + // TEST: send request when there is no conference + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + call3.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: send request when conference is not active + //------------------------------------------------------------------------- + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // test + call3.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: send request for call that is not in conference (different call mode) + //------------------------------------------------------------------------- + + RLine line2; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line2, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + callsInConference.AppendL(1); // call1 + callsInConference.AppendL(2); // call2 + + // dial 3rd call (status idle) + _LIT(KPhoneNumber3, "1632960000"); + DialL(call3, 3, RMobilePhone::EAuxVoiceService, KPhoneNumber3); + + // test + call3.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //----------------------------------------------------------------------------------- + // TEST: send request for call that is not in conference (call mode is EVoiceService) + //----------------------------------------------------------------------------------- + call3.Close(); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + + TName callName3; + OpenNewCallLC(call3, line2, &callName3); + CleanupStack::Pop(&call3); // call3 has already been put into the cleanup stack. + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + ChangeCallStatusL(3, RMobileCall::EStatusConnecting); + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + + // test + call3.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // add call3 to conference + AddCallL(conferenceCall, 3, callName3, callsInConference); + callsInConference.AppendL(3); // call3 + + //----------------------------------------------------------------------------------- + // TEST: place call on hold after requesting go one-to-one + //----------------------------------------------------------------------------------- + // test + TMockLtsyCallData0 emptyCallData3(3, RMobilePhone::EVoiceService); + emptyCallData3.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + call3.GoOneToOne(reqStatus); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotReady, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: send request for call that is not in conference (status hold) + //------------------------------------------------------------------------- + + // open 4th call + RMobileCall call4; + TName callName4; + OpenNewCallLC(call4, line2, &callName4); + + // dial 4th call (status hold) + _LIT(KPhoneNumber4, "1472583690"); + DialL(call4, 4, RMobilePhone::EVoiceService, KPhoneNumber4); + + // first put the conference call (call1, call2 and call3) on hold + ChangeCallStatusInOrderL(1, 3, RMobileCall::EStatusHold); + + ChangeCallStatusL(4, RMobileCall::EStatusConnecting); + ChangeCallStatusL(4, RMobileCall::EStatusConnected); + + // test + call4.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // add call4 to conference + AddCallL(conferenceCall, 4, callName4, callsInConference); + callsInConference.AppendL(4); // call4 + // add call5 to conference + RMobileCall call5; + _LIT(KPhoneNumber5, "9999999990"); + MakeCallAndAddToConferenceLC(call5, line2, conferenceCall, 5, KPhoneNumber5, callsInConference); + callsInConference.AppendL(5); // call5 + // test + TMockLtsyCallData0 emptyCallData4(4, RMobilePhone::EVoiceService); + emptyCallData4.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data, KErrNotSupported); + + call4.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::GoOneToOne. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + call4.GoOneToOne(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + ChangeCallStatusL(5, RMobileCall::EStatusHold); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileCall::GoOneToOne + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + //send completion + iMockLTSY.CompleteL(EMobileCallGoOneToOne, KErrNone, data); + // wait for completion + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: increase coverage + //------------------------------------------------------------------------- + + // make conference active (add 4th call to the hold conference) + AddCallL(conferenceCall, 4, callName4, callsInConference); + + // test + data.Close(); + emptyCallData4.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + call4.GoOneToOne(reqStatus); + + ChangeCallStatusL(5, RMobileCall::EStatusHold); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + ASSERT_EQUALS(KRequestPending, reqStatus.Int()); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: increase coverage + //------------------------------------------------------------------------- + + // make conference active (add 4th call to the hold conference) + AddCallL(conferenceCall, 4, callName4, callsInConference); + + // test + data.Close(); + TMockLtsyCallData0 emptyCallData5(5, RMobilePhone::EVoiceService); + emptyCallData5.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + call5.GoOneToOne(reqStatus); + + // test + ChangeCallStatusL(5, RMobileCall::EStatusDisconnecting); + + // GoOneToOne failed because call5 is disconnecting + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallGoOneToOne, KErrGeneral, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // call5 is in idle state + ChangeCallStatusL(5, RMobileCall::EStatusIdle); + + ChangeCallStatusL(3, RMobileCall::EStatusHold); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(4, RMobileCall::EStatusHold); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // close call5 object + CleanupStack::PopAndDestroy(&call5); + + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + // swap conference to active + data.Close(); + TMockLtsyCallData0 emptyCallData1(1, RMobilePhone::EVoiceService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallResume, data); + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + ChangeCallStatusL(4, RMobileCall::EStatusConnected); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // test + data.Close(); + emptyCallData4.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + iMockLTSY.CompleteL(EMobileCallGoOneToOne, KErrGeneral, data); + + call4.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(4, RMobileCall::EStatusHold); + + RMobileCall::TMobileCallCapsV1 caps; + RMobileCall::TMobileCallCapsV1Pckg capsDes(caps); + TInt res = call4.GetMobileCallCaps(capsDes); + ASSERT_EQUALS(KErrNone, res); + + //GoOneToOne operation is not be supported for call4. This is because + //call4 is already in connected state and other calls are in hold state. + TUint32 oneToOneNotSupported = 0; + ASSERT_EQUALS(oneToOneNotSupported, caps.iCallControlCaps & RMobileCall::KCapsOneToOne); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(10, this); // call4, call2, call, line2, conferenceCall, call3, line, callsInConference, data, this + + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGOTO-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::GoOneToOne for voice calls +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileCall::GoOneToOne for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGoOneToOne0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RMobileCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // open 3rd call for coverage + RCall call3; + OpenNewCallLC(call3, line); + _LIT(KPhoneNumber3, "3333333330"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + ChangeCallStatusL(3, RMobileCall::EStatusDialling); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileCall::GoOneToOne + //------------------------------------------------------------------------- + + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData0 emptyCallData1(1, mobileService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + + // post request + TRequestStatus reqStatus; + call.GoOneToOne(reqStatus); + + // cancel + call.CancelAsyncRequest(EMobileCallGoOneToOne); + + // invoke request completion from mockLtsy + ChangeCallStatusL(2, RMobileCall::EStatusHold); + + User::WaitForRequest(reqStatus); + // CTSY has no cancel for this ipc, so request completes with KErrNone + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(7, this); // call3, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGOTO-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::GoOneToOne for voice calls +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileCall::GoOneToOne for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGoOneToOne0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RArray callsInConference; + CleanupClosePushL(callsInConference); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RMobileCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + callsInConference.AppendL(1); // call1 + callsInConference.AppendL(2); // call2 + + // 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); + + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, phone2); + + // add 3rd call to conference from 2nd client + RLine line2; + TInt res = line2.Open(phone2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(line); + + RMobileCall call3; + _LIT(KPhoneNumber3, "1632960000"); + MakeCallAndAddToConferenceLC(call3, line2, conferenceCall2, 3, KPhoneNumber3, callsInConference); + callsInConference.AppendL(3); // call3 + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileCall::GoOneToOne + //------------------------------------------------------------------------- + + // post 1st request + TMockLtsyCallData0 emptyCallData1(1, RMobilePhone::EVoiceService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + TRequestStatus reqStatus; + call.GoOneToOne(reqStatus); + // check that EMobileCallGoOneToOne ipc request is passed to ltsy + AssertMockLtsyStatusL(); + + // post 2nd request + TRequestStatus reqStatus2; + call3.GoOneToOne(reqStatus2); + // check that request is not passed to ltsy + AssertMockLtsyStatusL(); + + // notify CTSY about changes in calls' statuses from mockLtsy + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + + // check results + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + User::WaitForRequest(reqStatus2); + ASSERT_EQUALS(KErrNotSupported, reqStatus2.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(12, this); // call3, line2, conferenceCall2, phone2, telServer2, call2, call, line, conferenceCall, callsInConference, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGOTO-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::GoOneToOne with timeout for voice calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::GoOneToOne and tests for timeout for voice calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGoOneToOne0005L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RMobileCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileCall::GoOneToOne + //------------------------------------------------------------------------- + + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData0 emptyCallData1(1, mobileService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + + TRequestStatus reqStatus; + call.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrTimedOut, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGOTO-0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::GoOneToOne for data calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::GoOneToOne for data calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGoOneToOne0006L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // open new line for calls + RLine line; + TInt res = line.Open(iPhone, KMmTsyDataLineName); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(line); + + // open call + RMobileCall call; + res = call.OpenNewCall(line); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(call); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::GoOneToOne when result is not cached. + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + call.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(3, this); // call, line, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGOTO-00011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileCall::GoOneToOne for fax calls +@SYMTestPriority High +@SYMTestActions Invokes RMobileCall::GoOneToOne for fax calls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGoOneToOne00011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // open new line for calls + RLine line; + TInt res = line.Open(iPhone, KMmTsyFaxLineName); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(line); + + // open call + RMobileCall call; + res = call.OpenNewCall(line); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(call); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileCall::GoOneToOne when result is not cached. + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + call.GoOneToOne(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(3, this); // call, line, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COEC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::EnumerateCalls +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::EnumerateCalls +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestEnumerateCalls0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RArray callsInConference; + CleanupClosePushL(callsInConference); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::EnumerateCalls when result is not cached. + //------------------------------------------------------------------------- + + TInt count; + TInt res = conferenceCall.EnumerateCalls(count); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(0, count); + AssertMockLtsyStatusL(); + + // create conference + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + callsInConference.AppendL(1); // call1 + callsInConference.AppendL(2); // call2 + + // calls enumeration request again + res = conferenceCall.EnumerateCalls(count); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(2, count); + AssertMockLtsyStatusL(); + + // add call to conference + RCall call3; + _LIT(KPhoneNumber3, "3333333330"); + MakeCallAndAddToConferenceLC(call3, line, conferenceCall, 3, KPhoneNumber3, callsInConference); + callsInConference.AppendL(3); // call3 + + // calls enumeration request again + res = conferenceCall.EnumerateCalls(count); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(3, count); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(7, this); // call3, call2, call, line, callsInConference, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COCC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::CreateConference +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::CreateConference +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestCreateConference0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference, KErrNotSupported); + + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + iMockLTSY.CompleteL(EMobileConferenceCallCreateConference, KErrGeneral); + + conferenceCall.CreateConference(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::CreateConference. + //------------------------------------------------------------------------- + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileConferenceCall::CreateConference + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + //send completion + iMockLTSY.CompleteL(EMobileConferenceCallCreateConference, KErrNone); + // wait for completion + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COCC-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileConferenceCall::CreateConference +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileConferenceCall::CreateConference +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestCreateConference0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileConferenceCall::CreateConference + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + iMockLTSY.CompleteL(EMobileConferenceCallCreateConference, KErrNone, 2); + + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + conferenceCall.CancelAsyncRequest(EMobileConferenceCallCreateConference); + + User::WaitForRequest(reqStatus); + // CTSY has no cancel for this ipc, so request completes with KErrNone + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + // Wait for completion of iMockLTSY.NotifyTerminated + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COCC-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileConferenceCall::CreateConference +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileConferenceCall::CreateConference +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestCreateConference0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // open new line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + OpenNewCallLC(call, line); + + // dial first call (make them hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // open second call + RCall call2; + OpenNewCallLC(call2, line); + + // dial second call (make them connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // --------------------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); + + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, phone2); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileConferenceCall::CreateConference + //------------------------------------------------------------------------- + + // first request + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + AssertMockLtsyStatusL(); + + // second request + TRequestStatus reqStatus2; + conferenceCall2.CreateConference(reqStatus2); + AssertMockLtsyStatusL(); + + // connect first call from mockLtsy + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + // refresh second call status from mockLtsy + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // check results + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + User::WaitForRequest(reqStatus2); + ASSERT_EQUALS(KErrNotReady, reqStatus2.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(8, this); // conferenceCall2, phone2, telServer2, call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COCC-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::CreateConference with timeout +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::CreateConference and tests for timeout +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestCreateConference0005L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileConferenceCall::CreateConference + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference, KErrNone); + + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrTimedOut, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(2, this); // conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COBDC-0001a +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for break down conference from LTSY for active conference +@SYMTestPriority High +@SYMTestActions Invokes break down conference from LTSY for active conference +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestBreakDownConference0001aL() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // open line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + TName callName; + OpenNewCallLC(call, line, &callName); + // dial first call (status connected) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // update first call status + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + + // open and connect second call exactly here for increase coverage + RCall call2; + OpenNewCallLC(call2, line); + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // conference is created here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for break down conference + // from LTSY for active conference + //-------------------------------- + + TRequestStatus statChangeStatus; + RMobileConferenceCall::TMobileConferenceStatus status; + conferenceCall.NotifyConferenceStatusChange(statChangeStatus, status); + + TRequestStatus notifyEventStatus; + RMobileConferenceCall::TMobileConferenceEvent event; + TName notifyCallName; + conferenceCall.NotifyConferenceEvent(notifyEventStatus, event, notifyCallName); + + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + + // notify requests complete here (actual test) + User::WaitForRequest(notifyEventStatus); + ASSERT_EQUALS(KErrNone, notifyEventStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, event); + + User::WaitForRequest(statChangeStatus); + ASSERT_EQUALS(KErrNone, statChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceIdle, status); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COBDC-0001b +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for break down conference from LTSY for hold conference +@SYMTestPriority High +@SYMTestActions Invokes break down conference from LTSY for hold conference +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestBreakDownConference0001bL() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // open line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + TName callName; + OpenNewCallLC(call, line, &callName); + + // dial first call (status hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // open call, dial (status connected) and make them idle for coverage + // (conference caps changes back to zero) + RCall someCall; + OpenNewCallLC(someCall, line); + _LIT(KSomePhoneNumber, "1632960000"); + DialL(someCall, 8, RMobilePhone::EVoiceService, KSomePhoneNumber); + ChangeCallStatusL(8, RMobileCall::EStatusConnected);// here conf.caps become KCapsCreate + ChangeCallStatusL(8, RMobileCall::EStatusIdle);// zero conf.caps + + // open second call + RCall call2; + OpenNewCallLC(call2, line); + // dial second call (status connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // connect first call + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + // update second call status + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // conference is created here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // swap conference + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData0 emptyCallData1(1, mobileService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallHold, data); + conferenceCall.Swap(reqStatus); + // if swap request did not pass to Ltsy the following assert will fail the test + AssertMockLtsyStatusL(); + + // set calls 1 and 2 on hold from MockLtsy + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + + // CTSY completes swap request here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + //-------------------------------- + // TEST: Test support in CTSY for break down conference + // from LTSY for hold conference + //-------------------------------- + + TRequestStatus statChangeStatus; + RMobileConferenceCall::TMobileConferenceStatus status; + conferenceCall.NotifyConferenceStatusChange(statChangeStatus, status); + + TRequestStatus notifyEventStatus; + RMobileConferenceCall::TMobileConferenceEvent event; + TName notifyCallName; + conferenceCall.NotifyConferenceEvent(notifyEventStatus, event, notifyCallName); + + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + + // notify requests complete here (actual test) + User::WaitForRequest(notifyEventStatus); + ASSERT_EQUALS(KErrNone, notifyEventStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, event); + + User::WaitForRequest(statChangeStatus); + ASSERT_EQUALS(KErrNone, statChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceIdle, status); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(7, this); // call2, someCall, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COBDC-0001c +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for break down conference from LTSY for active conference with hold call +@SYMTestPriority High +@SYMTestActions Invokes break down conference from LTSY for active conference with hold call +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestBreakDownConference0001cL() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // open line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + TName callName; + OpenNewCallLC(call, line, &callName); + // dial first call (status connected) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // update first call status + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + + // open and connect second call exactly here for increase coverage + RCall call2; + OpenNewCallLC(call2, line); + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // conference is created here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // create hold call for coverage + RCall call3; + OpenNewCallLC(call3, line); + _LIT(KPhoneNumber3, "3333333330"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + + //-------------------------------- + // TEST: Test support in CTSY for break down conference + // from LTSY for active conference with hold call + //-------------------------------- + + TRequestStatus statChangeStatus; + RMobileConferenceCall::TMobileConferenceStatus status; + conferenceCall.NotifyConferenceStatusChange(statChangeStatus, status); + + TRequestStatus notifyEventStatus; + RMobileConferenceCall::TMobileConferenceEvent event; + TName notifyCallName; + conferenceCall.NotifyConferenceEvent(notifyEventStatus, event, notifyCallName); + + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + + // notify request completes here (actual test) + User::WaitForRequest(notifyEventStatus); + ASSERT_EQUALS(KErrNone, notifyEventStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, event); + + User::WaitForRequest(statChangeStatus); + ASSERT_EQUALS(KErrNone, statChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceIdle, status); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // call3, call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COGCO-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for ghost operations from LTSY with conference +@SYMTestPriority High +@SYMTestActions Invokes ghost operations from LTSY with conference +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGhostConference0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // open line for calls + RLine line; + OpenLineLC(line); + + // open first call + RMobileCall call; + TName callName; + OpenNewCallLC(call, line, &callName); + + // dial first call (status hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // open second call + RCall call2; + TName callName2; + OpenNewCallLC(call2, line, &callName2); + + // dial second call (status connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + AssertMockLtsyStatusL(); + + // The following tests are to cover CMmConferenceCallGsmWcdmaExt::CompleteNotifyConferenceEvent() + + //-------------------------------- + // TEST: Test support in CTSY for ghost conference creation from LTSY + // in case when conference is creating through Etel too (just for increase coverage) + //-------------------------------- + + // send request through Etel + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // failing attempt to invoke starting of ghost conference creation + // (covering code) + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + TInt completeConfEvent = RMobileConferenceCall::EConferenceBuilt; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData1 completeGhostOperationData(1, mobileService, completeConfEvent); + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // then fail no more necessary etel request + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallCreateConference, KErrGeneral); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost add call to conference operation from LTSY + // over ghost add call to conference operation + // when conference is idle + //-------------------------------- + + // failing attempt to invoke starting of ghost add call to conference operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeConfEvent = RMobileConferenceCall::EConferenceCallAdded; + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //-------------------------------- + // TEST: Test support in CTSY for ghost swap operation from LTSY + // when conference is idle + //-------------------------------- + + // failing attempt to invoke starting of ghost swap conference operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeConfEvent = RMobileConferenceCall::EConferenceSwapped; + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //-------------------------------- + // TEST: Test support in CTSY for ghost conference creation from LTSY + //-------------------------------- + + // post conference status change notify request + TRequestStatus statusChangeStatus; + RMobileConferenceCall::TMobileConferenceStatus mobileConfStatus; + conferenceCall.NotifyConferenceStatusChange(statusChangeStatus, mobileConfStatus); + + // post conference event notify request + TRequestStatus confEventStatus; + RMobileConferenceCall::TMobileConferenceEvent event; + TName notifyCallName; + conferenceCall.NotifyConferenceEvent(confEventStatus, event, notifyCallName); + + // invoke starting of ghost conference creation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeConfEvent = RMobileConferenceCall::EConferenceBuilt; + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // connect first call + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + + // notify conference event completes here (intermediate test) + User::WaitForRequest(confEventStatus); + ASSERT_EQUALS(KErrNone, confEventStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + // repost conference event notify request + conferenceCall.NotifyConferenceEvent(confEventStatus, event, notifyCallName); + + // update second call status + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // notify conference event completes here (intermediate test) + User::WaitForRequest(confEventStatus); + ASSERT_EQUALS(KErrNone, confEventStatus.Int()); + ASSERT_EQUALS(callName2, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + + // here completes ghost conference creation + // notify conference status change completes here (actual test) + User::WaitForRequest(statusChangeStatus); + ASSERT_EQUALS(KErrNone, statusChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, mobileConfStatus); + + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost add call to conference operation from LTSY + // over ghost build conference operation + // when call is adding through Etel (just for increase coverage) + //-------------------------------- + + // open 3rd call + RCall call3; + TName callName3; + OpenNewCallLC(call3, line, &callName3); + + // dial 3rd call (status hold) + _LIT(KPhoneNumber3, "3333333330"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + // First put the conference call (call1 and call2) on hold + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusHold); + // Then change the status of call3 in correct order so that right capabilities can be assigned + ConnectAndPutCallOnHoldInRightOrderL(3); + + // send add call request through Etel + TMockLtsyCallData0 emptyCallDataServiceUnspecified3(3, RMobilePhone::EServiceUnspecified); + data.Close(); + emptyCallDataServiceUnspecified3.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + conferenceCall.AddCall(reqStatus, callName3); + + // failing attempt to invoke starting of ghost add call operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // then fail no more necessary etel request + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallAddCall, KErrGeneral); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost add call to conference operation from LTSY + // over ghost build conference operation + //-------------------------------- + + // post conference event notify request + conferenceCall.NotifyConferenceEvent(confEventStatus, event, notifyCallName); + + // invoke starting of ghost add call to conference operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // connect conference calls + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusConnected); + // connect 3rd call + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + + // notify conference event completes here (actual test) + User::WaitForRequest(confEventStatus); + ASSERT_EQUALS(KErrNone, confEventStatus.Int()); + ASSERT_EQUALS(callName3, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost add call to conference operation from LTSY + // over ghost add call to conference operation + // when call is adding through Etel (just for increase coverage) + //-------------------------------- + + // open 4th call + RCall call4; + TName callName4; + OpenNewCallLC(call4, line, &callName4); + + // dial 4th call (status hold) + _LIT(KPhoneNumber4, "4444444440"); + DialL(call4, 4, RMobilePhone::EVoiceService, KPhoneNumber4); + // put the conference call (call1, call2 and call3) on hold + ChangeCallStatusInOrderL(1, 3, RMobileCall::EStatusHold); + ConnectAndPutCallOnHoldInRightOrderL(4); + + // send add call request through Etel + TMockLtsyCallData0 emptyCallDataServiceUnspecified4(4, RMobilePhone::EServiceUnspecified); + data.Close(); + emptyCallDataServiceUnspecified4.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + conferenceCall.AddCall(reqStatus, callName4); + + // failing attempt to invoke starting of ghost add call operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeConfEvent = RMobileConferenceCall::EConferenceCallAdded; + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // then fail no more necessary etel request + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallAddCall, KErrGeneral); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost add call to conference operation from LTSY + // over ghost add call to conference operation + //-------------------------------- + + // post conference event notify request + conferenceCall.NotifyConferenceEvent(confEventStatus, event, notifyCallName); + + // invoke starting of ghost add call to conference operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // make the conference(call1, call2 and call3) call active + ChangeCallStatusInOrderL(1, 3, RMobileCall::EStatusConnected); + // connect 4th call + ChangeCallStatusL(4, RMobileCall::EStatusConnected); + + // notify conference event completes here (actual test) + User::WaitForRequest(confEventStatus); + ASSERT_EQUALS(KErrNone, confEventStatus.Int()); + ASSERT_EQUALS(callName4, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost GoOneToOne operation from LTSY + // when GoOneToOne is called through Etel (just for increase coverage) + //-------------------------------- + + // call GoOneToOne through Etel + TMockLtsyCallData0 emptyCallData1(1, mobileService); + data.Close(); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallGoOneToOne, data); + call.GoOneToOne(reqStatus); + + // failing attempt to invoke starting of ghost go one to one operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeConfEvent = RMobileConferenceCall::EConferenceSplit; + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // then fail no more necessary etel request + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + emptyCallData1.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallGoOneToOne, KErrGeneral, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost GoOneToOne operation from LTSY + //-------------------------------- + + // post conference status change notify request + do + { + conferenceCall.NotifyConferenceStatusChange(statusChangeStatus, mobileConfStatus); + } + while ( statusChangeStatus.Int() != KRequestPending ); + + // post conference event notify request + conferenceCall.NotifyConferenceEvent(confEventStatus, event, notifyCallName); + + // invoke starting of ghost go one to one operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // make 1st call the only connected call + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + ChangeCallStatusL(4, RMobileCall::EStatusHold); + + // notify conference event completes here (actual test) + User::WaitForRequest(confEventStatus); + ASSERT_EQUALS(KErrNone, confEventStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, event); + // notify conference status change completes here (actual test) + User::WaitForRequest(statusChangeStatus); + ASSERT_EQUALS(KErrNone, statusChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceHold, mobileConfStatus); + + // repost conference event notify request + conferenceCall.NotifyConferenceEvent(confEventStatus, event, notifyCallName); + // notify conference event completes here (actual test) + User::WaitForRequest(confEventStatus); + ASSERT_EQUALS(KErrNone, confEventStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceSplit, event); + + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost swap operation from LTSY + // when swap is called through Etel (just for increase coverage) + //-------------------------------- + + // call Swap through Etel + iMockLTSY.ExpectL(EMobileConferenceCallSwap); + conferenceCall.Swap(reqStatus); + + // failing attempt to invoke starting of ghost swap conference operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + completeConfEvent = RMobileConferenceCall::EConferenceSwapped; + completeGhostOperationData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // then fail no more necessary etel request + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallSwap, KErrGeneral); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost swap operation from LTSY + // when conference is hold + //-------------------------------- + + // post conference status change notify request + conferenceCall.NotifyConferenceStatusChange(statusChangeStatus, mobileConfStatus); + + // invoke starting of ghost swap conference operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // make 1st call the only hold call + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + ChangeCallStatusL(4, RMobileCall::EStatusConnected); + + // notify conference status change completes here (actual test) + User::WaitForRequest(statusChangeStatus); + ASSERT_EQUALS(KErrNone, statusChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, mobileConfStatus); + + AssertMockLtsyStatusL(); + + //-------------------------------- + // TEST: Test support in CTSY for ghost swap operation from LTSY + // when conference is active + //-------------------------------- + + // post conference status change notify request + conferenceCall.NotifyConferenceStatusChange(statusChangeStatus, mobileConfStatus); + + // invoke starting of ghost swap conference operation + // (covering code) + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallNotifyConferenceEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // make 1st call the only connected call + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + ChangeCallStatusL(4, RMobileCall::EStatusHold); + + // notify conference status change completes here (actual test) + User::WaitForRequest(statusChangeStatus); + ASSERT_EQUALS(KErrNone, statusChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceHold, mobileConfStatus); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(8, this); // call4, call3, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::NotifyCapsChange +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::NotifyCapsChange +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyCapsChange0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::NotifyCapsChange. + //------------------------------------------------------------------------- + + // post request + TRequestStatus notifyStatus; + TUint32 caps; + conferenceCall.NotifyCapsChange(notifyStatus, caps); + + // open new line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + OpenNewCallLC(call, line); + + // dial first call (status hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // open second call + RCall call2; + OpenNewCallLC(call2, line); + + // dial second call (status connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // completion of notify request (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(static_cast(RMobileConferenceCall::KCapsCreate), caps); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: Increase coverage (lets create conference) + //------------------------------------------------------------------------- + + // repost request + conferenceCall.NotifyCapsChange(notifyStatus, caps); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // make first call connected + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + // update second call status (connected) + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // conference is created + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // completion of notify request (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(static_cast(RMobileConferenceCall::KCapsHangUp | + RMobileConferenceCall::KCapsSwap), caps); + + //------------------------------------------------------------------------- + // TEST: Increase coverage (lets hangup conference) + //------------------------------------------------------------------------- + + // repost request + conferenceCall.NotifyCapsChange(notifyStatus, caps); + + // hangup conference + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + conferenceCall.HangUp(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + ChangeCallStatusL(2, RMobileCall::EStatusIdle); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // completion of notify request (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(static_cast(0), caps); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCC-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileConferenceCall::NotifyCapsChange +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileConferenceCall::NotifyCapsChange +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyCapsChange0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileConferenceCall::NotifyCapsChange + //------------------------------------------------------------------------- + + // post request + TRequestStatus notifyStatus; + TUint32 caps; + conferenceCall.NotifyCapsChange(notifyStatus, caps); + + // cancel + conferenceCall.CancelAsyncRequest(EMobileConferenceCallNotifyCapsChange); + + // completion of notify request + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrCancel, notifyStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2); // conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCC-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileConferenceCall::NotifyCapsChange +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileConferenceCall::NotifyCapsChange +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyCapsChange0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // 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); + + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, phone2); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileConferenceCall::NotifyCapsChange + //------------------------------------------------------------------------- + + // post request + TRequestStatus notifyStatus; + TUint32 caps; + conferenceCall.NotifyCapsChange(notifyStatus, caps); + + TRequestStatus notifyStatus2; + TUint32 caps2; + conferenceCall2.NotifyCapsChange(notifyStatus2, caps2); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // completion of 1st notify request + User::WaitForRequest(notifyStatus); + // completion of 2nd notify request + User::WaitForRequest(notifyStatus2); + + // check results + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(static_cast(RMobileConferenceCall::KCapsCreate), caps); + + ASSERT_EQUALS(KErrNone, notifyStatus2.Int()); + ASSERT_EQUALS(static_cast(RMobileConferenceCall::KCapsCreate), caps2); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(8, this); // call2, call, line, conferenceCall2, phone2, telServer2, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COGCS-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::GetConferenceStatus +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::GetConferenceStatus +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGetConferenceStatus0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::GetConferenceStatus. + //------------------------------------------------------------------------- + + RMobileConferenceCall::TMobileConferenceStatus status; + TInt res = conferenceCall.GetConferenceStatus(status); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceIdle, status); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: Successful completion request of + // RMobileConferenceCall::GetConferenceStatus with other Caps value. + //------------------------------------------------------------------------- + + // invoke conference status change + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // test + res = conferenceCall.GetConferenceStatus(status); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, status); + AssertMockLtsyStatusL(); + + // invoke conference status change (swap conference) + TMockLtsyCallData0 emptyCallData(1, RMobilePhone::EVoiceService); + emptyCallData.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallHold, data); + TRequestStatus reqStatus; + conferenceCall.Swap(reqStatus); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // test again + res = conferenceCall.GetConferenceStatus(status); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceHold, status); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(6, this); // call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCE-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::NotifyConferenceEvent +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::NotifyConferenceEvent +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyConferenceEvent0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::NotifyConferenceEvent. + //------------------------------------------------------------------------- + + // post request + TRequestStatus notifyStatus; + RMobileConferenceCall::TMobileConferenceEvent event; + TName notifyCallName; + conferenceCall.NotifyConferenceEvent(notifyStatus, event, notifyCallName); + + // open new line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + TName callName; + OpenNewCallLC(call, line, &callName); + + // dial first call (status hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // open second call + RCall call2; + TName callName2; + OpenNewCallLC(call2, line, &callName2); + + // dial second call (status connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // make first call connected + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + + // notify request completes here (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + + //------------------------------------------------------------------------- + // TEST: Increase coverage (conference creation continues) + //------------------------------------------------------------------------- + + // repost tested request + conferenceCall.NotifyConferenceEvent(notifyStatus, event, notifyCallName); + + // update second call status (connected) + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // notify request completes here (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(callName2, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + + //------------------------------------------------------------------------- + // TEST: Increase coverage (conference creation continues) + //------------------------------------------------------------------------- + + // repost tested request + conferenceCall.NotifyConferenceEvent(notifyStatus, event, notifyCallName); + + // conference creation request completes here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // notify request completes here (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + TName callsInConference; + callsInConference.Zero (); + callsInConference.Append (callName2); + callsInConference.Append (KDelimiter); + callsInConference.Append (callName); + ASSERT_EQUALS(callsInConference, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceBuilt, event); + + //------------------------------------------------------------------------- + // TEST: Increase coverage (lets hangup conference) + //------------------------------------------------------------------------- + + // repost tested request + conferenceCall.NotifyConferenceEvent(notifyStatus, event, notifyCallName); + + // hangup conference + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + conferenceCall.HangUp(reqStatus); + + // make 1st call idle + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + + // notify request completes here (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, event); + + //------------------------------------------------------------------------- + // TEST: Increase coverage (conference hangup continues) + //------------------------------------------------------------------------- + + // repost tested request + conferenceCall.NotifyConferenceEvent(notifyStatus, event, notifyCallName); + + // make 2nd call idle + ChangeCallStatusL(2, RMobileCall::EStatusIdle); + + // notify request completes here (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(callName2, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, event); + + // here completes hangup request + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCE-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileConferenceCall::NotifyConferenceEvent +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileConferenceCall::NotifyConferenceEvent +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyConferenceEvent0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileConferenceCall::NotifyConferenceEvent + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + RMobileConferenceCall::TMobileConferenceEvent event; + TName callName; + conferenceCall.NotifyConferenceEvent(reqStatus, event, callName); + + conferenceCall.CancelAsyncRequest(EMobileConferenceCallNotifyConferenceEvent); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrCancel, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(2); // conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCE-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileConferenceCall::NotifyConferenceEvent +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileConferenceCall::NotifyConferenceEvent +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyConferenceEvent0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // 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); + + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, phone2); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileConferenceCall::NotifyConferenceEvent + //------------------------------------------------------------------------- + + // post request + TRequestStatus notifyStatus; + RMobileConferenceCall::TMobileConferenceEvent event; + TName notifyCallName; + conferenceCall.NotifyConferenceEvent(notifyStatus, event, notifyCallName); + + TRequestStatus notifyStatus2; + RMobileConferenceCall::TMobileConferenceEvent event2; + TName notifyCallName2; + conferenceCall2.NotifyConferenceEvent(notifyStatus2, event2, notifyCallName2); + + // open new line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + TName callName; + OpenNewCallLC(call, line, &callName); + + // dial first call (status hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // open second call + RCall call2; + TName callName2; + OpenNewCallLC(call2, line, &callName2); + + // dial second call (status connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // make first call connected + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + + // notify request completes here (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(callName, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + + User::WaitForRequest(notifyStatus2); + ASSERT_EQUALS(KErrNone, notifyStatus2.Int()); + ASSERT_EQUALS(callName, notifyCallName2); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event2); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: Increase coverage (conference creation continues) + //------------------------------------------------------------------------- + + // repost tested request + conferenceCall.NotifyConferenceEvent(notifyStatus, event, notifyCallName); + conferenceCall2.NotifyConferenceEvent(notifyStatus2, event2, notifyCallName2); + + // update second call status (connected) + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // notify request completes here (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(callName2, notifyCallName); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event); + + User::WaitForRequest(notifyStatus2); + ASSERT_EQUALS(KErrNone, notifyStatus2.Int()); + ASSERT_EQUALS(callName2, notifyCallName2); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, event2); + AssertMockLtsyStatusL(); + + // conference creation request completes here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(8, this); // call2, call, line, conferenceCall2, phone2, telServer2, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCSC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::NotifyConferenceStatusChange +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::NotifyConferenceStatusChange +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyConferenceStatusChange0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::NotifyConferenceStatusChange. + //------------------------------------------------------------------------- + + // post request + TRequestStatus notifyStatus; + RMobileConferenceCall::TMobileConferenceStatus status; + conferenceCall.NotifyConferenceStatusChange(notifyStatus, status); + + // invoke conference status change + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // completion of notify request + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, status); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: Successful completion request of + // RMobileConferenceCall::NotifyConferenceStatusChange with other Caps value. + //------------------------------------------------------------------------- + + // post request + conferenceCall.NotifyConferenceStatusChange(notifyStatus, status); + + // hangup conference + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + TRequestStatus reqStatus; + conferenceCall.HangUp(reqStatus); + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + ChangeCallStatusL(2, RMobileCall::EStatusIdle); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + // completion of notify request (actual test) + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceIdle, status); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCSC-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileConferenceCall::NotifyConferenceStatusChange +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileConferenceCall::NotifyConferenceStatusChange +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyConferenceStatusChange0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileConferenceCall::NotifyConferenceStatusChange + //------------------------------------------------------------------------- + + TRequestStatus notifyStatus; + RMobileConferenceCall::TMobileConferenceStatus status; + conferenceCall.NotifyConferenceStatusChange(notifyStatus, status); + + conferenceCall.CancelAsyncRequest(EMobileConferenceCallNotifyConferenceStatusChange); + + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrCancel, notifyStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(2); // conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CONCSC-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileConferenceCall::NotifyConferenceStatusChange +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileConferenceCall::NotifyConferenceStatusChange +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestNotifyConferenceStatusChange0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // 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); + + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, phone2); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileConferenceCall::NotifyConferenceStatusChange + //------------------------------------------------------------------------- + + // post request + TRequestStatus notifyStatus; + RMobileConferenceCall::TMobileConferenceStatus status; + conferenceCall.NotifyConferenceStatusChange(notifyStatus, status); + + // post request + TRequestStatus notifyStatus2; + RMobileConferenceCall::TMobileConferenceStatus status2; + conferenceCall2.NotifyConferenceStatusChange(notifyStatus2, status2); + + // invoke conference status change + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // completion of notify request + User::WaitForRequest(notifyStatus); + ASSERT_EQUALS(KErrNone, notifyStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, status); + + User::WaitForRequest(notifyStatus2); + ASSERT_EQUALS(KErrNone, notifyStatus2.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, status2); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(8, this); // call2, call, line, conferenceCall2, phone2, telServer2, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COS-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::Swap +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::Swap +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestSwap0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST: failure to swap not created conference call + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotReady, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A1: failure to dispatch request to LTSY + // when conference is active and no hold calls. + //------------------------------------------------------------------------- + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData0 emptyCallData1(1, mobileService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallHold, data, KErrNotSupported); + + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B1: failure on completion of pending request from LTSY->CTSY + // when conference is active and no hold calls. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileCallHold, data); + + iMockLTSY.CompleteL(EMobileConferenceCallSwap, KErrGeneral); + + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C1: Successful completion request of + // RMobileConferenceCall::Swap + // when conference is active and no hold calls. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileCallHold, data); + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A2: failure to dispatch request to LTSY + // when conference is hold and no active calls. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileCallResume, data, KErrNotSupported); + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B2: failure on completion of pending request from LTSY->CTSY + // when conference is hold and no active calls. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileCallResume, data); + iMockLTSY.CompleteL(EMobileConferenceCallSwap, KErrGeneral); + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C2: Successful completion request of + // RMobileConferenceCall::Swap + // when conference is hold and no active calls. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileCallResume, data); + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A3: failure to dispatch request to LTSY + // when conference is active and there is a hold call. + //------------------------------------------------------------------------- + + // dial 3rd call (status hold) + RCall call3; + OpenNewCallLC(call3, line); + _LIT(KPhoneNumber3, "3333333330"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + + // open 4th call for increase coverage objectives + RCall call4; + OpenNewCallLC(call4, line); + + // test + iMockLTSY.ExpectL(EMobileConferenceCallSwap, KErrNotSupported); + + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B3: failure on completion of pending request from LTSY->CTSY + // when conference is active and there is a hold call. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallSwap); + iMockLTSY.CompleteL(EMobileConferenceCallSwap, KErrGeneral); + + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C3: Successful completion request of + // RMobileConferenceCall::Swap + // when conference is active and there is a hold call. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallSwap); + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A4: failure to dispatch request to LTSY + // when conference is hold and there is an active call. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallSwap, KErrNotSupported); + + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B4: failure on completion of pending request from LTSY->CTSY + // when conference is hold and there is an active call. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallSwap); + iMockLTSY.CompleteL(EMobileConferenceCallSwap, KErrGeneral); + + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C4: Successful completion request of + // RMobileConferenceCall::Swap + // when conference is hold and there is an active call. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallSwap); + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(3, RMobileCall::EStatusHold); + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileConferenceCall::Swap + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallSwap, KErrNone); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C3-2: Successful completion request of + // RMobileConferenceCall::Swap + // when conference is active and there is a hold call. + // This time hold call become idle + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallSwap); + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusIdle); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: swap conference without swap request and without ghost swap operation + // increase coverage + //------------------------------------------------------------------------- + + TRequestStatus statChangeStatus; + RMobileConferenceCall::TMobileConferenceStatus status; + conferenceCall.NotifyConferenceStatusChange(statChangeStatus, status); + + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); // conference become active + + // completion of notify request + User::WaitForRequest(statChangeStatus); + ASSERT_EQUALS(KErrNone, statChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, status); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: swap conference without swap request and without ghost swap operation + // this time conference is active + // increase coverage + //------------------------------------------------------------------------- + + conferenceCall.NotifyConferenceStatusChange(statChangeStatus, status); + + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); // conference become hold + + // completion of notify request + User::WaitForRequest(statChangeStatus); + ASSERT_EQUALS(KErrNone, statChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceHold, status); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: make conference idle when there is requested a swap + //------------------------------------------------------------------------- + + conferenceCall.NotifyConferenceStatusChange(statChangeStatus, status); + + data.Close(); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallResume, data); + conferenceCall.Swap(reqStatus); + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + + // completion of notify request + User::WaitForRequest(statChangeStatus); + ASSERT_EQUALS(KErrNone, statChangeStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceIdle, status); + + // swap request completes with error + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrMMEtelCallTerminated, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(8, this); // call4, call3, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COS-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileConferenceCall::Swap +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileConferenceCall::Swap +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestSwap0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileConferenceCall::Swap + //------------------------------------------------------------------------- + + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData0 emptyCallData1(1, mobileService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallHold, data); + + // post request + TRequestStatus reqStatus; + conferenceCall.Swap(reqStatus); + + // cancel + conferenceCall.CancelAsyncRequest(EMobileConferenceCallSwap); + + // invoke request completion from mockLtsy + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + + User::WaitForRequest(reqStatus); + // CTSY has no cancel for this ipc, so request completes with KErrNone + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(6, this); // call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COS-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileConferenceCall::Swap +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileConferenceCall::Swap +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestSwap0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // 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); + + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, phone2); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileConferenceCall::Swap + //------------------------------------------------------------------------- + + // prepare and post 1st request + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData0 emptyCallData1(1, mobileService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallHold, data); + + // set calls on hold when request passes to Ltsy after delay + data.Close(); + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusHold; + TMockLtsyCallData1 completeCallStatusData1(1, mobileService, callStatus); + completeCallStatusData1.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + data.Close(); + TMockLtsyCallData1 completeCallStatusData2(2, mobileService, callStatus); + completeCallStatusData2.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + TRequestStatus reqStatus; + conferenceCall.Swap(reqStatus); + + // prepare and post 2nd request + data.Close(); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallResume, data); + + // connect calls when request passes to Ltsy after delay + data.Close(); + callStatus = RMobileCall::EStatusConnected; + completeCallStatusData1.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + data.Close(); + completeCallStatusData2.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + TRequestStatus reqStatus2; + conferenceCall2.Swap(reqStatus2); + + // check results + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + User::WaitForRequest(reqStatus2); + ASSERT_EQUALS(KErrNone, reqStatus2.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(9, this); // conferenceCall2, phone2, telServer2, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COS-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::Swap with timeout +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::Swap and tests for timeout +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestSwap0005L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileConferenceCall::Swap + //------------------------------------------------------------------------- + + TMockLtsyCallData0 emptyCallData1(1, RMobilePhone::EVoiceService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallHold, data); + + TRequestStatus reqStatus; + conferenceCall.Swap(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrTimedOut, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(6, this); // call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COHU-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::HangUp +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::HangUp +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestHangUp0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RArray callsInConference; + CleanupClosePushL(callsInConference); + + //------------------------------------------------------------------------- + // TEST: failure to hangup not created conference call + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + conferenceCall.HangUp(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrAccessDenied, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + callsInConference.AppendL(1); // call1 + callsInConference.AppendL(2); // call2 + + iMockLTSY.ExpectL(EMobileConferenceCallHangUp, KErrNotSupported); + + conferenceCall.HangUp(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + iMockLTSY.CompleteL(EMobileConferenceCallHangUp, KErrGeneral); + + conferenceCall.HangUp(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::CreateConference. + //------------------------------------------------------------------------- + + // add more calls to conference for coverage + RCall call3; + _LIT(KPhoneNumber3, "3333333330"); + MakeCallAndAddToConferenceLC(call3, line, conferenceCall, 3, KPhoneNumber3, callsInConference); + callsInConference.AppendL(3); // call3 + + RCall call4; + _LIT(KPhoneNumber4, "4444444440"); + MakeCallAndAddToConferenceLC(call4, line, conferenceCall, 4, KPhoneNumber4, callsInConference); + callsInConference.AppendL(4); // call4 + + RCall call5; + _LIT(KPhoneNumber5, "5555555550"); + MakeCallAndAddToConferenceLC(call5, line, conferenceCall, 5, KPhoneNumber5, callsInConference); + callsInConference.AppendL(5); // call5 + + // create a hold call out of the conference + RCall call6; + OpenNewCallLC(call6, line); + _LIT(KPhoneNumber6, "6666666660"); + DialL(call6, 6, RMobilePhone::EVoiceService, KPhoneNumber6); + // Put the conference call (call1, call2, call3, call4 and call5) on hold + ChangeCallStatusInOrderL(1, 5, RMobileCall::EStatusHold); + // Connect call6 in right order + ConnectAndPutCallOnHoldInRightOrderL(6); + + // now test begins + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + conferenceCall.HangUp(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusDisconnecting); // just for coverage + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + ChangeCallStatusL(2, RMobileCall::EStatusIdle); + ChangeCallStatusL(3, RMobileCall::EStatusIdle); + ChangeCallStatusL(4, RMobileCall::EStatusIdle); + ChangeCallStatusL(5, RMobileCall::EStatusIdle); + + // hangup completes here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileConferenceCall::CreateConference + // from LTSY. + //------------------------------------------------------------------------- + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + // send completion + iMockLTSY.CompleteL(EMobileConferenceCallHangUp, KErrNone); + // wait for completion + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + + // + // 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). + // + + // open conference object + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, iPhone); + + RArray callsInConference2; + CleanupClosePushL(callsInConference2); + + RLine line2; + RCall call21; + RCall call22; + CreateConferenceLC(iPhone, conferenceCall2, line2, call21, 21, KPhoneNumber1, call22, 22, KPhoneNumber2); + callsInConference2.AppendL(21); + callsInConference2.AppendL(22); + + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + iMockLTSY.CompleteL(EMobileConferenceCallHangUp, KErrGsmReleaseByUser); + conferenceCall2.HangUp(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + + CleanupStack::PopAndDestroy(15, this); // call22, call21, line2, callsInConference2, conferenceCall2, call6, call5, call4, call3, call2, call, line, callsInConference, conferenceCall, this + + } + +/** +@SYMTestCaseID BA-CTSY-CONC-COHU-0001b +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for events related to RMobileConferenceCall::HangUp +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::HangUp. Checks events are triggered correctly. +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestHangUp0001bL() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + RLine line; + TRequestStatus reqStatus; + TRequestStatus hangupStatus; + RMobileConferenceCall::TMobileConferenceEvent whatStatus; + TName callName; + RCall::TCallInfo callInfo; + + // add calls to conference + RCall call1; + _LIT(KPhoneNumber1, "1111111110"); + RCall call2; + _LIT(KPhoneNumber2, "22222222220"); + CreateConferenceLC(iPhone, conferenceCall, line, call1, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + // now test begins + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + conferenceCall.NotifyConferenceEvent(hangupStatus, whatStatus, callName); + conferenceCall.HangUp(reqStatus); + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + ChangeCallStatusL(2, RMobileCall::EStatusIdle); + + // hangup completes here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + //Three Events are to be expected. One EConferenceCallRemoved for each call + //in the conference and one EConferenceTerminated. + User::WaitForRequest(hangupStatus); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, whatStatus); + call1.GetInfo(callInfo); + ASSERT_EQUALS(callInfo.iCallName, callName); + + conferenceCall.NotifyConferenceEvent(hangupStatus, whatStatus, callName); + User::WaitForRequest(hangupStatus); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallRemoved, whatStatus); + call2.GetInfo(callInfo); + ASSERT_EQUALS(callInfo.iCallName, callName); + + conferenceCall.NotifyConferenceEvent(hangupStatus, whatStatus, callName); + User::WaitForRequest(hangupStatus); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceTerminated, whatStatus); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call2, call1, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COHU-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileConferenceCall::HangUp +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileConferenceCall::HangUp +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestHangUp0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RArray callsInConference; + CleanupClosePushL(callsInConference); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + callsInConference.AppendL(1); // call1 + callsInConference.AppendL(2); // call2 + + // add more calls to conference for coverage issues + RCall call3; + _LIT(KPhoneNumber3, "3333333330"); + MakeCallAndAddToConferenceLC(call3, line, conferenceCall, 3, KPhoneNumber3, callsInConference); + callsInConference.AppendL(3); // call3 + + RCall call4; + _LIT(KPhoneNumber4, "4444444440"); + MakeCallAndAddToConferenceLC(call4, line, conferenceCall, 4, KPhoneNumber4, callsInConference); + callsInConference.AppendL(4); // call4 + + RCall call5; + _LIT(KPhoneNumber5, "5555555550"); + MakeCallAndAddToConferenceLC(call5, line, conferenceCall, 5, KPhoneNumber5, callsInConference); + callsInConference.AppendL(5); // call5 + + // swap conference for coverage + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData0 emptyCallData1(1, mobileService); + emptyCallData1.SerialiseL(data); + iMockLTSY.ExpectL(EMobileCallHold, data); + TRequestStatus reqStatus; + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + ChangeCallStatusL(4, RMobileCall::EStatusHold); + ChangeCallStatusL(5, RMobileCall::EStatusHold); + + // swap completes here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileConferenceCall::HangUp + //------------------------------------------------------------------------- + + // send request + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + conferenceCall.HangUp(reqStatus); + + // cancel + conferenceCall.CancelAsyncRequest(EMobileConferenceCallHangUp); + + // mockLtsy completes request + ChangeCallStatusL(1, RMobileCall::EStatusIdle); + ChangeCallStatusL(2, RMobileCall::EStatusIdle); + ChangeCallStatusL(3, RMobileCall::EStatusIdle); + ChangeCallStatusL(4, RMobileCall::EStatusIdle); + + //Change call5 status to idle + RMobileCall::TMobileCallStatus callStatus5 = RMobileCall::EStatusIdle; + RMobilePhone::TMobileService mobileService5 = RMobilePhone::EVoiceService; + TMockLtsyCallData1 mockData5(5, mobileService5, callStatus5); + data.Close(); + mockData5.SerialiseL(data); + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data); + + // when call becomes idle, remaining duration of the call is added to life time param in LTSY: + TUint32 duration = 5; // this is a dummy value, which won't be checked by mocksy engine + TMockLtsyData1 ltsyData( duration ); + data.Close(); + ltsyData.SerialiseL(data); + iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, data); + + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // hangup completes here + User::WaitForRequest(reqStatus); + // CTSY has no cancel for this ipc, so request completes with KErrNone + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(10, this); // call5, call4, call3, call2, call, line, callsInConference, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COHU-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileConferenceCall::HangUp +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileConferenceCall::HangUp +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestHangUp0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // Open second client + RTelServer telServer2; + TInt res = telServer2.Connect(); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(telServer2); + + RMobilePhone phone2; + res = phone2.Open(telServer2, KMmTsyPhoneName); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(phone2); + + // open conference object + RMobileConferenceCall conferenceCall2; + OpenConferenceLC(conferenceCall2, phone2); + + TRequestStatus reqStatus; + TRequestStatus reqStatus2; + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileConferenceCall::HangUp + //------------------------------------------------------------------------- + + // prepare and send 1st request + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + + // complete request from mockLtsy when request passes to ltsy with delay + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusIdle; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData1 completeCallStatusData1(1, mobileService, callStatus); + completeCallStatusData1.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + data.Close(); + TMockLtsyCallData1 completeCallStatusData2(2, mobileService, callStatus); + completeCallStatusData2.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + conferenceCall.HangUp(reqStatus); + + // send 2nd request + conferenceCall2.HangUp(reqStatus2); + + // check results + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + User::WaitForRequest(reqStatus2); + ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(9, this); // conferenceCall2, phone2, telServer2, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COHU-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::HangUp with timeout +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::HangUp and tests for timeout +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestHangUp0005L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileConferenceCall::HangUp + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallHangUp); + + TRequestStatus reqStatus; + conferenceCall.HangUp(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrTimedOut, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COAC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::AddCall +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::AddCall +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestAddCall0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RArray callsInConference; + CleanupClosePushL(callsInConference); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall,iPhone); + + // open line for calls + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + OpenNewCallLC(call, line); + // dial first call (status hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // create a call to add to the conference + RCall call3; + TName callName3; + OpenNewCallLC(call3, line, &callName3); + + // create a hold call out of the conference (just for increase coverage) + RCall call4; + TName callName4; + OpenNewCallLC(call4, line, &callName4); + _LIT(KPhoneNumber4, "4444444440"); + DialL(call4, 4, RMobilePhone::EVoiceService, KPhoneNumber4); + ChangeCallStatusL(4, RMobileCall::EStatusHold); + + // open second call + RMobileCall call2; + TName callName2; + OpenNewCallLC(call2, line, &callName2); + // dial second call (status connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + //------------------------------------------------------------------------- + // TEST: add idle call + //------------------------------------------------------------------------- + + TRequestStatus reqStatus; + conferenceCall.AddCall(reqStatus, callName3); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrArgument, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST: add call when conference is idle + //------------------------------------------------------------------------- + + // dial call3 (status hold) + _LIT(KPhoneNumber3, "3333333330"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + ConnectAndPutCallOnHoldInRightOrderL(3); + + // test + conferenceCall.AddCall(reqStatus, callName3); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrArgument, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + conferenceCall.CreateConference(reqStatus); + + // connect first call + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + // update second call status + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // conference is created here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // test + TMockLtsyCallData0 emptyCallDataServiceUnspecified3(3, RMobilePhone::EServiceUnspecified); + emptyCallDataServiceUnspecified3.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data, KErrNotSupported); + + conferenceCall.AddCall(reqStatus, callName3); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNotSupported, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + iMockLTSY.CompleteL(EMobileConferenceCallAddCall, KErrGeneral); + + conferenceCall.AddCall(reqStatus, callName3); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::AddCall. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + conferenceCall.AddCall(reqStatus, callName3); + + RMobileCall::TMobileCallEvent completeEvent(RMobileCall::ERemoteTerminated); + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + TMockLtsyCallData1 callEventData(2, mobileService, completeEvent); + + // this call event completion is just for increase coverage + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + data.Close(); + callEventData.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // this complete is just for increase coverage + ChangeCallStatusL(2, RMobileCall::EStatusIdle); + + // this complete is just for increase coverage + ChangeCallStatusL(4, RMobileCall::EStatusIdle); + + // this complete is just for increase coverage + ChangeCallStatusL(3, RMobileCall::EStatusHold); + + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + + // now only call1 and call3 are in conference + callsInConference.AppendL(1); // call1 + callsInConference.AppendL(3); // call3 + + // add call request completes here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + TInt count; + TInt res = conferenceCall.EnumerateCalls(count); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(2, count); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST E: Unsolicited completion of RMobileConferenceCall::AddCall + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(EMobileConferenceCallAddCall, KErrNone); + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST F: Tests that a call that connect without connecting can be added to a conference. + //------------------------------------------------------------------------- + RCall callOnlyConnect; + TName callNameOnlyConnect; + _LIT(KPhoneNumberOnlyConnect, "8888888881"); + ChangeConferenceCallStatusL(callsInConference, RMobileCall::EStatusHold); + + // Then open the call and dial + OpenNewCallLC(callOnlyConnect, line, &callNameOnlyConnect); + DialL(callOnlyConnect, 9, RMobilePhone::EVoiceService, KPhoneNumberOnlyConnect); + // Apply only connected status changes + ChangeCallStatusL(9, RMobileCall::EStatusConnected); + + data.Close(); + TMockLtsyCallData0 emptyCallDataServiceUnspecified9(9, RMobilePhone::EServiceUnspecified); + emptyCallDataServiceUnspecified9.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data, KErrNone); + iMockLTSY.CompleteL(EMobileConferenceCallAddCall, KErrNone); + + // Try to add the call to the conference. + conferenceCall.AddCall(reqStatus, callNameOnlyConnect); + User::WaitForRequest(reqStatus); + TInt ttt = reqStatus.Int(); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + ChangeConferenceCallStatusL(callsInConference, RMobileCall::EStatusConnected); + + AddCallL(conferenceCall, 9, callNameOnlyConnect, callsInConference); + callsInConference.Append(9); + + //------------------------------------------------------------------------- + // TEST G: Tests that a call with lack of KCapsJoin capability cannot be added to a conference. + //------------------------------------------------------------------------- + // call2 doesn't have join capability since it is in idle mode. + conferenceCall.AddCall(reqStatus, callName2); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrArgument, reqStatus.Int()); + + // KCapsJoin capability is not assigned to a new call if 5 calls are present in an ongoing conference. + RCall call6; // 4th call in the conference + _LIT(KPhoneNumber6, "6666666660"); + MakeCallAndAddToConferenceLC(call6, line, conferenceCall, 6, KPhoneNumber6, callsInConference); + callsInConference.AppendL(6); // call6 + + RCall call7; // 5th call in the conference + _LIT(KPhoneNumber7, "7777777770"); + MakeCallAndAddToConferenceLC(call7, line, conferenceCall, 7, KPhoneNumber7, callsInConference); + callsInConference.AppendL(7); // call7 + + RCall call8; // 6th call in the conference + TName callName8; + _LIT(KPhoneNumber8, "8888888880"); + // First put the conference call on hold + ChangeConferenceCallStatusL(callsInConference, RMobileCall::EStatusHold); + // Then open the call and dial + OpenNewCallLC(call8, line, &callName8); + DialL(call8, 8, RMobilePhone::EVoiceService, KPhoneNumber8); + // Apply all expected status changes so that capabilities can be assigned correctly + ChangeCallStatusL(8, RMobileCall::EStatusConnecting); + ChangeCallStatusL(8, RMobileCall::EStatusConnected); + + // Try to add the 6th call to the conference. This operations should fail with KErrArgument as a conference can have maximum 5 members. + conferenceCall.AddCall(reqStatus, callName8); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrMMEtelMaxReached, reqStatus.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(13, this); // call8, call7, call6, callOnlyConnect, call4, call3, call2, call, line, conferenceCall, callsInConference, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COAC-0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileConferenceCall::AddCall +@SYMTestPriority High +@SYMTestActions Invokes cancelling of RMobileConferenceCall::AddCall +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestAddCall0002L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // open 3rd call + RCall call3; + TName callName3; + OpenNewCallLC(call3, line, &callName3); + + // dial 3rd call (status hold) + _LIT(KPhoneNumber3, "1632960000"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + // put the conference call on hold + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusHold); + ConnectAndPutCallOnHoldInRightOrderL(3); + // make the conference call active + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusConnected); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileConferenceCall::AddCall + //------------------------------------------------------------------------- + + // send request + TMockLtsyCallData0 emptyCallDataServiceUnspecified3(3, RMobilePhone::EServiceUnspecified); + emptyCallDataServiceUnspecified3.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + TRequestStatus reqStatus; + conferenceCall.AddCall(reqStatus, callName3); + + // cancel + conferenceCall.CancelAsyncRequest(EMobileConferenceCallAddCall); + + // mockLtsy completes request + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + + // check results + User::WaitForRequest(reqStatus); + // there is no cancel for this ipc in ctsy + // so status is KErrNone + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(7, this); // call3, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COAC-0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::AddCall with bad parameter data +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::AddCall with bad parameter data +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestAddCall0003L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // Test C: Test passing out of bounds parameters to + // RMobileConferenceCall::AddCall + //------------------------------------------------------------------------- + + TName name(KNullDesC); + + TRequestStatus reqStatus; + conferenceCall.AddCall(reqStatus, name); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrArgument, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(2, this); // conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COAC-0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileConferenceCall::AddCall +@SYMTestPriority High +@SYMTestActions Invokes multiple client requests to RMobileConferenceCall::AddCall +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestAddCall0004L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // open 3rd call + RCall call3; + TName callName3; + OpenNewCallLC(call3, line, &callName3); + + // dial 3rd call (status hold) + _LIT(KPhoneNumber3, "1632960000"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + // put the conference call on hold + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusHold); + ConnectAndPutCallOnHoldInRightOrderL(3); + // make the conference call active + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusConnected); + + // ------------------- 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); + + // open new line for calls + RLine secLine; + TInt res = secLine.Open(phone2, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(secLine); + + // open call + RCall secCall; + TName secCallName; + OpenNewCallLC(secCall, secLine, &secCallName); + + // dial call + _LIT(KSecPhoneNumber1, "1632960000"); + DialL(secCall, 4, RMobilePhone::EVoiceService, KSecPhoneNumber1); + ChangeCallStatusL(4, RMobileCall::EStatusConnecting); + ChangeCallStatusL(4, RMobileCall::EStatusConnected); + + // open conference object + RMobileConferenceCall secConferenceCall; + OpenConferenceLC(secConferenceCall, phone2); + + //------------------------------------------------------------------------- + // Test A: Test multiple clients requesting RMobileConferenceCall::AddCall + //------------------------------------------------------------------------- + + // first request + TMockLtsyCallData0 emptyCallDataServiceUnspecified3(3, RMobilePhone::EServiceUnspecified); + emptyCallDataServiceUnspecified3.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + + data.Close(); + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 completeCallStatusData3(3, RMobilePhone::EVoiceService, callStatus); + completeCallStatusData3.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + TRequestStatus reqStatus; + conferenceCall.AddCall(reqStatus, callName3); + + // second request + TMockLtsyCallData0 emptyCallDataServiceUnspecified4(4, RMobilePhone::EServiceUnspecified); + data.Close(); + emptyCallDataServiceUnspecified4.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + + data.Close(); + RMobileCall::TMobileCallStatus secCallStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 secCompleteCallStatusData1(4, RMobilePhone::EVoiceService, secCallStatus); + secCompleteCallStatusData1.SerialiseL(data); + iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data, 10); + + TRequestStatus secReqStatus; + secConferenceCall.AddCall(secReqStatus, secCallName); + + // check results + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + User::WaitForRequest(secReqStatus); + ASSERT_EQUALS(KErrNone, secReqStatus.Int()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(12, this); // secConferenceCall, secCall, secLine, phone2, telServer2, call3, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COAC-0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::AddCall with timeout +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::AddCall and tests for timeout +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestAddCall0005L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // open conference object + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + // open 3rd call + RCall call3; + TName callName3; + OpenNewCallLC(call3, line, &callName3); + + // dial 3rd call (status hold) + _LIT(KPhoneNumber3, "1632960000"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + // put the conference call on hold + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusHold); + ConnectAndPutCallOnHoldInRightOrderL(3); + // make the conference call active + ChangeCallStatusInOrderL(1, 2, RMobileCall::EStatusConnected); + + //------------------------------------------------------------------------- + // Test A: Test timeout of RMobileConferenceCall::AddCall + //------------------------------------------------------------------------- + + TMockLtsyCallData0 emptyCallDataServiceUnspecified3(3, RMobilePhone::EServiceUnspecified); + emptyCallDataServiceUnspecified3.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + + TRequestStatus reqStatus; + conferenceCall.AddCall(reqStatus, callName3); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrTimedOut, reqStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(7, this); // call3, call2, call, line, conferenceCall, data, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-COGC-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::GetCaps +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::GetCaps +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGetCaps0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileConferenceCall::GetCaps. + //------------------------------------------------------------------------- + + TUint32 caps; + TInt res = conferenceCall.GetCaps(caps); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(static_cast(0), caps); + + //------------------------------------------------------------------------- + // TEST: Successful completion request of + // RMobileConferenceCall::GetCaps with other Caps value. + //------------------------------------------------------------------------- + + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + res = conferenceCall.GetCaps(caps); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(static_cast(RMobileConferenceCall::KCapsSwap | + RMobileConferenceCall::KCapsHangUp), caps); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGMCI-0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::GetMobileCallInfo +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::GetMobileCallInfo +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGetMobileCallInfo0001L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + //------------------------------------------------------------------------- + // TEST: Send request of RMobileConferenceCall::GetMobileCallInfo + // when conference is idle + //------------------------------------------------------------------------- + + RMobileCall::TMobileCallInfoV1 info; + RMobileCall::TMobileCallInfoV1Pckg infoPckg(info); + TInt res = conferenceCall.GetMobileCallInfo(0, infoPckg); + ASSERT_EQUALS(KErrNotReady, res); + + //------------------------------------------------------------------------- + // TEST C1: Successful completion request of + // RMobileConferenceCall::GetMobileCallInfo + // when conference is active + //------------------------------------------------------------------------- + + // create conference + RLine line; + OpenLineLC(line); + + // open first call + RCall call; + TName callName1; + OpenNewCallLC(call, line, &callName1); + // dial first call (status hold) + _LIT(KPhoneNumber1, "1357924680"); + DialL(call, 1, RMobilePhone::EVoiceService, KPhoneNumber1); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + + // create a hold call out of the conference (just for increase coverage) + RCall call3; + OpenNewCallLC(call3, line); + _LIT(KPhoneNumber3, "3333333330"); + DialL(call3, 3, RMobilePhone::EVoiceService, KPhoneNumber3); + ChangeCallStatusL(3, RMobileCall::EStatusHold); + + // open second call + RCall call2; + TName callName2; + OpenNewCallLC(call2, line, &callName2); + // dial second call (status connected) + _LIT(KPhoneNumber2, "1234567890"); + DialL(call2, 2, RMobilePhone::EVoiceService, KPhoneNumber2); + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + conferenceCall.CreateConference(reqStatus); + + // connect first call + ChangeCallStatusL(1, RMobileCall::EStatusConnected); + // update second call status + ChangeCallStatusL(2, RMobileCall::EStatusConnected); + + // conference is created here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + + sleep(2); + + // test (get info for 2nd call (index = 1)) + res = conferenceCall.GetMobileCallInfo(1, infoPckg); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(static_cast(RMobileCall::KCallStartTime | + RMobileCall::KCallDuration | + RMobileCall::KCallId | + RMobileCall::KCallExitCode | + RMobileCall::KCallEmergency | + RMobileCall::KCallRemoteParty | + RMobileCall::KCallDialledParty | + RMobileCall::KCallAlternating), info.iValid); + ASSERT_EQUALS(callName2, info.iCallName); + ASSERT_TRUE( 0 == KMmTsyVoice1LineName().Compare(info.iLineName) ); + ASSERT_EQUALS(RMobileCall::EStatusConnected, info.iStatus); + const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0); + ASSERT_EQUALS(0, memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime))); + ASSERT_TRUE( TTimeIntervalSeconds(0) == info.iDuration ); + ASSERT_EQUALS(2, info.iCallId); + ASSERT_EQUALS(0, info.iExitCode); + ASSERT_EQUALS(0, info.iEmergency); + ASSERT_EQUALS(RMobilePhone::EAlternatingModeUnspecified, info.iAlternatingCall); + ASSERT_EQUALS(RMobileCall::ERemoteIdentityUnknown, info.iRemoteParty.iRemoteIdStatus); + ASSERT_EQUALS(RMobileCall::EMobileOriginated, info.iRemoteParty.iDirection); + ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteParty.iRemoteNumber.iTypeOfNumber); + ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteParty.iRemoteNumber.iNumberPlan); + ASSERT_EQUALS(0, info.iRemoteParty.iRemoteNumber.iTelNumber.Size()); + ASSERT_EQUALS(0, info.iRemoteParty.iCallingName.Size()); + ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iDialledParty.iTypeOfNumber); + ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iDialledParty.iNumberPlan); + ASSERT_TRUE( 0 == KPhoneNumber2().Compare(info.iDialledParty.iTelNumber) ); + ASSERT_EQUALS(RMobilePhone::EVoiceService, info.iService); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C2: Successful completion request of + // RMobileConferenceCall::GetMobileCallInfo + // when conference is hold + //------------------------------------------------------------------------- + + // swap conference + iMockLTSY.ExpectL(EMobileConferenceCallSwap); + conferenceCall.Swap(reqStatus); + + ChangeCallStatusL(3, RMobileCall::EStatusConnected); + ChangeCallStatusL(1, RMobileCall::EStatusHold); + ChangeCallStatusL(2, RMobileCall::EStatusHold); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + + // test (get info for 1st call (index = 0)) + res = conferenceCall.GetMobileCallInfo(0, infoPckg); + ASSERT_EQUALS(KErrNone, res); + ASSERT_EQUALS(static_cast(RMobileCall::KCallStartTime | + RMobileCall::KCallDuration | + RMobileCall::KCallId | + RMobileCall::KCallExitCode | + RMobileCall::KCallEmergency | + RMobileCall::KCallRemoteParty | + RMobileCall::KCallDialledParty | + RMobileCall::KCallAlternating), info.iValid); + ASSERT_EQUALS(callName1, info.iCallName); + ASSERT_TRUE( 0 == KMmTsyVoice1LineName().Compare(info.iLineName) ); + ASSERT_EQUALS(RMobileCall::EStatusHold, info.iStatus); + ASSERT_EQUALS(0, memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime))); + ASSERT_TRUE( TTimeIntervalSeconds(0) == info.iDuration ); + ASSERT_EQUALS(1, info.iCallId); + ASSERT_EQUALS(0, info.iExitCode); + ASSERT_EQUALS(0, info.iEmergency); + ASSERT_EQUALS(RMobilePhone::EAlternatingModeUnspecified, info.iAlternatingCall); + ASSERT_EQUALS(RMobileCall::ERemoteIdentityUnknown, info.iRemoteParty.iRemoteIdStatus); + ASSERT_EQUALS(RMobileCall::EMobileOriginated, info.iRemoteParty.iDirection); + ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteParty.iRemoteNumber.iTypeOfNumber); + ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteParty.iRemoteNumber.iNumberPlan); + ASSERT_EQUALS(0, info.iRemoteParty.iRemoteNumber.iTelNumber.Size()); + ASSERT_EQUALS(0, info.iRemoteParty.iCallingName.Size()); + ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iDialledParty.iTypeOfNumber); + ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iDialledParty.iNumberPlan); + ASSERT_TRUE( 0 == KPhoneNumber1().Compare(info.iDialledParty.iTelNumber) ); + ASSERT_EQUALS(RMobilePhone::EVoiceService, info.iService); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(6, this); // call2, call3, call, line, conferenceCall, this + } + + +/** +@SYMTestCaseID BA-CTSY-CONC-CGMCI-0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileConferenceCall::GetMobileCallInfo with bad parameter data +@SYMTestPriority High +@SYMTestActions Invokes RMobileConferenceCall::GetMobileCallInfo with bad parameter data +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyConferenceCallControlFU::TestGetMobileCallInfo0003L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileConferenceCall conferenceCall; + OpenConferenceLC(conferenceCall, iPhone); + + // create conference + RLine line; + RCall call; + RCall call2; + _LIT(KPhoneNumber1, "1357924680"); + _LIT(KPhoneNumber2, "1234567890"); + CreateConferenceLC(iPhone, conferenceCall, line, call, 1, KPhoneNumber1, call2, 2, KPhoneNumber2); + + //------------------------------------------------------------------------- + // Test C: Test passing out of bounds parameters to + // RMobileConferenceCall::GetMobileCallInfo + //------------------------------------------------------------------------- + + RMobileCall::TMobileCallInfoV1 info; + RMobileCall::TMobileCallInfoV1Pckg infoPckg(info); + TInt res = conferenceCall.GetMobileCallInfo(2, infoPckg); //wrong index + ASSERT_EQUALS(KErrNotFound, res); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // Test B: Test passing wrong descriptor size to parameter in + // RMobileConferenceCall::GetMobileCallInfo + //------------------------------------------------------------------------- + + ERR_PRINTF2(_L("$CTSYKnownFailure: defect id = %d"), 201701); + ASSERT_TRUE(EFalse); + + TBuf8<1> smallSizeBuf; + res = conferenceCall.GetMobileCallInfo(0, smallSizeBuf); + ASSERT_TRUE(KErrNone != res); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // call2, call, line, conferenceCall, this + + } + + +void CCTsyConferenceCallControlFU::CreateConferenceLC(RPhone& aPhone, + RMobileConferenceCall& aConferenceCall, + RLine& aLine, + RCall& aCall, + TInt aCallId1, + const TDesC &aTelNumber1, + RCall& aCall2, + TInt aCallId2, + const TDesC &aTelNumber2) + { + + TInt errorCode = aLine.Open(aPhone, KMmTsyVoice1LineName); + ASSERT_EQUALS(KErrNone, errorCode) + CleanupClosePushL(aLine); + + // open first call + OpenNewCallLC(aCall, aLine); + + // dial first call (status hold) + DialL(aCall, aCallId1, RMobilePhone::EVoiceService, aTelNumber1); + ChangeCallStatusL(aCallId1, RMobileCall::EStatusHold); + + // open second call + OpenNewCallLC(aCall2, aLine); + + // dial second call (status connected) + DialL(aCall2, aCallId2, RMobilePhone::EVoiceService, aTelNumber2); + ChangeCallStatusL(aCallId2, RMobileCall::EStatusConnected); + + // create conference + iMockLTSY.ExpectL(EMobileConferenceCallCreateConference); + TRequestStatus reqStatus; + aConferenceCall.CreateConference(reqStatus); + + // connect first call + ChangeCallStatusL(aCallId1, RMobileCall::EStatusConnected); + // update second call status + ChangeCallStatusL(aCallId2, RMobileCall::EStatusConnected); + + // conference is created here + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + + } + +void CCTsyConferenceCallControlFU::OpenConferenceLC(RMobileConferenceCall& aConferenceCall, RMobilePhone& aPhone) + { + TInt res = aConferenceCall.Open(aPhone); + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(aConferenceCall); + } + +void CCTsyConferenceCallControlFU::OpenLineLC(RLine& aLine, const TDesC& aName) + { + CCtsyComponentTestBase::OpenLineLC(aLine, aName); + } + +void CCTsyConferenceCallControlFU::OpenNewCallLC(RCall& aCall, RLine& aLine, TDes* aCallName) + { + TInt res; + if (aCallName) + { + res = aCall.OpenNewCall(aLine, *aCallName); + } + else + { + res = aCall.OpenNewCall(aLine); + } + ASSERT_EQUALS(KErrNone, res); + CleanupClosePushL(aCall); + } + +void CCTsyConferenceCallControlFU::ChangeConferenceCallStatusL(const RArray& aCallsInConference, RMobileCall::TMobileCallStatus aCallStatus) + { + TInt count = aCallsInConference.Count(); + + for(TInt i=0; i& aCallsInConference) + { + // First put the conference call on hold + ChangeConferenceCallStatusL(aCallsInConference, RMobileCall::EStatusHold); + + TName callName; + OpenNewCallLC(aCall, aLine, &callName); + DialL(aCall, aCallId, RMobilePhone::EVoiceService, aTelNumber); + // Apply all expected status changes so that capabilities can be assigned correctly + ChangeCallStatusL(aCallId, RMobileCall::EStatusConnecting); + ChangeCallStatusL(aCallId, RMobileCall::EStatusConnected); + AddCallL(aConferenceCall, aCallId, callName, aCallsInConference); + } + +void CCTsyConferenceCallControlFU::ChangeCallStatusL(TInt aCallId, + RMobileCall::TMobileCallStatus aCallStatus) + { + CCtsyComponentTestBase::ChangeCallStatusL(aCallId, RMobilePhone::EVoiceService, aCallStatus); + } + +void CCTsyConferenceCallControlFU::ChangeCallStatusInOrderL(TInt aStartCallId, TInt aEndCallId, RMobileCall::TMobileCallStatus aCallStatus) + { + for(TInt i=aStartCallId; i<=aEndCallId; ++i) + { + ChangeCallStatusL(i, aCallStatus); + } + } + +void CCTsyConferenceCallControlFU::ConnectAndPutCallOnHoldInRightOrderL(TInt aCallId) + { + // a call cannot go from Idle state to Hold state directly + // change the status of call in order below so that right capabilities can be assigned + ChangeCallStatusL(aCallId, RMobileCall::EStatusConnecting); + ChangeCallStatusL(aCallId, RMobileCall::EStatusConnected); + ChangeCallStatusL(aCallId, RMobileCall::EStatusHold); + } + +void CCTsyConferenceCallControlFU::AddCallL(RMobileConferenceCall& aConferenceCall, + TInt aCallId, + const TName& aCallName, + const RArray& aCallsInConference) + { + + // prepare add call request + RBuf8 data; + data.CleanupClosePushL(); + + TMockLtsyCallData0 emptyCallDataServiceUnspecified(aCallId, RMobilePhone::EServiceUnspecified); + emptyCallDataServiceUnspecified.SerialiseL(data); + iMockLTSY.ExpectL(EMobileConferenceCallAddCall, data); + + CleanupStack::PopAndDestroy(&data); + + // send request + TRequestStatus reqStatus; + aConferenceCall.AddCall(reqStatus, aCallName); + + // First make the conference call active + ChangeConferenceCallStatusL(aCallsInConference, RMobileCall::EStatusConnected); + + // request is now completed + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + AssertMockLtsyStatusL(); + + }