diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsycallcontrolmultipartyfunegative.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsycallcontrolmultipartyfunegative.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,650 @@ +// Copyright (c) 2008-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: +// when support for the various APIs are disabled in the dispatch layer. +// + + + +/** + @file The TEFUnit test suite for SmsControl in the Common TSY +*/ + +#include "cctsycallcontrolmultipartyfunegative.h" + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include "mockltsyindicatorids.h" + +#include "config.h" + + +CTestSuite* CCTsyCallControlMultipartyFUNegative::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlMultipartyFUNegative, TestHangUpL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlMultipartyFUNegative, TestAddCallL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlMultipartyFUNegative, TestCreateConferenceL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlMultipartyFUNegative, TestSwapL); + ADD_TEST_STEP_ISO_CPP(CCTsyCallControlMultipartyFUNegative, TestGoOneToOneL); + END_SUITE; + } + +/** + * @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0001 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the Hangup API is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsyCallControlMultipartyFUNegative::TestHangUpL() + { + // Note: based on original non-negative test void CCTsyCallControlMultipartyFU::TestUseCase0003L() + + TConfig config; + config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId, EFalse); + config.PushL(); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + DriverCreateConferenceCallL(mobileService, callId1, callId2); + + DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse); + DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing); + + // Client side test + + RMobileLine mobileLine; + CleanupClosePushL(mobileLine); + RMobileCall mobileCall; + CleanupClosePushL(mobileCall); + + RMobileLine mobileLine2; + CleanupClosePushL(mobileLine2); + RMobileCall mobileCall2; + CleanupClosePushL(mobileCall2); + + ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine, + mobileCall2, mobileLine2); + + RMobileConferenceCall confCall; + CleanupClosePushL(confCall); + + TRequestStatus notifyCall1Status; + RMobileCall::TMobileCallStatus call1Status; + mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status); + + ClientCreateConferenceCallL(confCall); + + User::WaitForRequest(notifyCall1Status); + ASSERT_EQUALS(KErrNone, notifyCall1Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusConnected, call1Status); + + TRequestStatus hangupStatus; + confCall.HangUp(hangupStatus); + User::WaitForRequest(hangupStatus); + ASSERT_EQUALS(KErrNotSupported, hangupStatus.Int()); + + // Boths calls should still be connected + RMobileCall::TMobileCallStatus callStatus; + ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallStatus(callStatus)); + ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus); + ASSERT_EQUALS(KErrNone, mobileCall2.GetMobileCallStatus(callStatus)); + ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus); + + // Hang up the calls + ClientHangUpCallL(mobileCall); + ClientHangUpCallL(mobileCall2); + + User::After(100000); // Allow the lifetimer to be updated before ending the test + + mobileCall.Close(); + mobileCall2.Close(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(8, &config); // confCall, this, config + } + + +/** + * @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0002 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the AddCall API is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsyCallControlMultipartyFUNegative::TestAddCallL() + { + // Note: based on non-negative test CCTsyCallControlMultipartyFU::TestUseCase0007L() + + TConfig config; + config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceAddCall::KLtsyDispatchCallControlMultipartyConferenceAddCallApiId, EFalse); + config.PushL(); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + DriverCreateConferenceCallAndHoldItL(mobileService, callId1, callId2); + + TInt callId3 = 3; + DriverDialCallL(callId3, mobileService); + + DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse); + DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing, EFalse); + DriverHangUpCallL(callId3, KErrGsmCCNormalCallClearing); + + // Client side test + + RMobileLine mobileLine; + CleanupClosePushL(mobileLine); + RMobileCall mobileCall; + CleanupClosePushL(mobileCall); + + RMobileLine mobileLine2; + CleanupClosePushL(mobileLine2); + RMobileCall mobileCall2; + CleanupClosePushL(mobileCall2); + + ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine, + mobileCall2, mobileLine2); + + RMobileConferenceCall confCall; + CleanupClosePushL(confCall); + + TRequestStatus notifyCall1Status; + RMobileCall::TMobileCallStatus call1Status; + mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status); + + ClientCreateConferenceCallL(confCall); + + User::WaitForRequest(notifyCall1Status); + ASSERT_EQUALS(KErrNone, notifyCall1Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusConnected, call1Status); + + mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status); + + TRequestStatus notifyCall2Status; + RMobileCall::TMobileCallStatus call2Status; + mobileCall2.NotifyMobileCallStatusChange(notifyCall2Status, call2Status); + + ClientSwapConferenceCallL(confCall, RMobileConferenceCall::EConferenceSwapped, + RMobileConferenceCall::EConferenceHold); + + User::WaitForRequest(notifyCall1Status); + ASSERT_EQUALS(KErrNone, notifyCall1Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusHold, call1Status); + + User::WaitForRequest(notifyCall2Status); + ASSERT_EQUALS(KErrNone, notifyCall2Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusHold, call2Status); + + // Dial a new call and attempt to add it to the conference + RMobileLine mobileLine3; + CleanupClosePushL(mobileLine3); + RMobileCall mobileCall3; + CleanupClosePushL(mobileCall3); + + ClientDialCallL(mobileLine3, mobileCall3, mobileService); + + RMobileCall::TMobileCallInfoV1 callInfo; + RMobileCall::TMobileCallInfoV1Pckg callInfoPckg(callInfo); + ASSERT_EQUALS(KErrNone, mobileCall3.GetMobileCallInfo(callInfoPckg)); + + TRequestStatus status; + confCall.AddCall(status, callInfo.iCallName); + User::WaitForRequest(status); + ASSERT_EQUALS(status.Int(), KErrNotSupported); + + // Hang up the calls + ClientHangUpCallL(mobileCall); + ClientHangUpCallL(mobileCall2); + ClientHangUpCallL(mobileCall3); + + User::After(100000); // Allow the lifetimer to be updated before ending the test + + mobileCall.Close(); + mobileCall2.Close(); + mobileCall3.Close(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(9, &config); + } + + + +/** + * @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0003 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the CreateConference API is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsyCallControlMultipartyFUNegative::TestCreateConferenceL() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchCallControlMultipartyCreateConference::KLtsyDispatchCallControlMultipartyCreateConferenceApiId, EFalse); + config.PushL(); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + // Set up correct conditions to be able to create a conference + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + DriverDialAndHoldFirstCallDialSecondCallL(mobileService, callId1, callId2); + + RMobileLine mobileLine; + CleanupClosePushL(mobileLine); + RMobileCall mobileCall; + CleanupClosePushL(mobileCall); + + RMobileLine mobileLine2; + CleanupClosePushL(mobileLine2); + RMobileCall mobileCall2; + CleanupClosePushL(mobileCall2); + + ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine, + mobileCall2, mobileLine2); + + RMobileConferenceCall confCall; + CleanupClosePushL(confCall); + ASSERT_EQUALS(KErrNone, confCall.Open(iPhone)); + + // Hang up cause for normal hang up + DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse); + DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing); + + TRequestStatus status; + confCall.CreateConference(status); + User::WaitForRequest(status); + ASSERT_EQUALS(status.Int(), KErrNotSupported); + + // Hang up the calls + ClientHangUpCallL(mobileCall); + ClientHangUpCallL(mobileCall2); + + User::After(100000); // Allow the lifetimer to be updated before ending the test + + mobileCall.Close(); + mobileCall2.Close(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(8, &config); + } + + + +/** + * @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0004 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the Swap API is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsyCallControlMultipartyFUNegative::TestSwapL() + { + // Note: Equiv non-negative test is CCTsyCallControlMultipartyFU::TestUseCase0006L + + TConfig config; + config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceSwap::KLtsyDispatchCallControlMultipartyConferenceSwapApiId, EFalse); + config.PushL(); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + DriverCreateConferenceCallAndHoldItL(mobileService, callId1, callId2); + + TInt callId3 = 3; + DriverDialCallL(callId3, mobileService); + + DriverHangUpCallL(callId1, KErrGsmCCNormalCallClearing, EFalse); + DriverHangUpCallL(callId2, KErrGsmCCNormalCallClearing, EFalse); + DriverHangUpCallL(callId3, KErrGsmCCNormalCallClearing); + + // Client side test + + RMobileLine mobileLine; + CleanupClosePushL(mobileLine); + RMobileCall mobileCall; + CleanupClosePushL(mobileCall); + + RMobileLine mobileLine2; + CleanupClosePushL(mobileLine2); + RMobileCall mobileCall2; + CleanupClosePushL(mobileCall2); + + RMobileConferenceCall confCall; + CleanupClosePushL(confCall); + + ClientCreateConferenceCallAndHoldItL(mobileService, mobileCall, + mobileLine, mobileCall2, mobileLine2, confCall); + + TRequestStatus notifyCall1Status; + RMobileCall::TMobileCallStatus call1Status; + mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status); + + TRequestStatus notifyCall2Status; + RMobileCall::TMobileCallStatus call2Status; + mobileCall2.NotifyMobileCallStatusChange(notifyCall2Status, call2Status); + + // Dial a new call and attempt to swap the conference with it + RMobileLine mobileLine3; + CleanupClosePushL(mobileLine3); + RMobileCall mobileCall3; + CleanupClosePushL(mobileCall3); + + ClientDialCallL(mobileLine3, mobileCall3, mobileService); + + User::WaitForRequest(notifyCall1Status); + ASSERT_EQUALS(KErrNone, notifyCall1Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusConnected, call1Status); + + mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status); + + TRequestStatus swapStatus; + confCall.Swap(swapStatus); + User::WaitForRequest(swapStatus); + ASSERT_EQUALS(KErrNotSupported, swapStatus.Int()); + + User::WaitForRequest(notifyCall1Status); + ASSERT_EQUALS(KErrNone, notifyCall1Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusHold, call1Status); + + User::WaitForRequest(notifyCall2Status); + ASSERT_EQUALS(KErrNone, notifyCall2Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusHold, call2Status); + + RMobileConferenceCall::TMobileConferenceStatus confStatus; + ASSERT_EQUALS(KErrNone, confCall.GetConferenceStatus(confStatus)); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceHold, confStatus); + + // Hang up the calls + ClientHangUpCallL(mobileCall); + ClientHangUpCallL(mobileCall2); + ClientHangUpCallL(mobileCall3); + + User::After(100000); // Allow the lifetimer to be updated before ending the test + + mobileCall.Close(); + mobileCall2.Close(); + mobileCall3.Close(); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(10, &config); + } + + +/** + * @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROLMULTIPARTY-NEGATIVE-UN0005 + * @SYMComponent telephony_ctsy + * @SYMTestCaseDesc Test handing in CTSY dispatch when the GoOneToOne API is disabled + * @SYMTestPriority High + * @SYMTestActions Disable API, call API, check correct error returned + * @SYMTestExpectedResults Pass + * @SYMTestType CT + */ +void CCTsyCallControlMultipartyFUNegative::TestGoOneToOneL() + { + // Note: Equiv non-negative test CCTsyCallControlMultipartyFU::TestUseCase0008L() + + TConfig config; + config.SetSupportedValue(MLtsyDispatchCallControlMultipartyConferenceGoOneToOne::KLtsyDispatchCallControlMultipartyConferenceGoOneToOneApiId, EFalse); + config.PushL(); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + TInt callId1 = 1; + TInt callId2 = 2; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + DriverCreateConferenceCallL(mobileService, callId1, callId2); + + RArray callIds; + CleanupClosePushL( callIds ); + callIds.AppendL( callId1 ); + callIds.AppendL( callId2 ); + + TMockLtsyData1 > ltsyData(callIds); + data.Close(); + ltsyData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchCallControlMultipartyConferenceHangUp::KLtsyDispatchCallControlMultipartyConferenceHangUpApiId, KErrNone); + + DriverCompleteSuccessfulHangUpNotificationsL(callId1, EFalse, KErrGsmCCNormalCallClearing, EFalse); + DriverCompleteSuccessfulHangUpNotificationsL(callId2, EFalse, KErrGsmCCNormalCallClearing, ETrue); + + // Client Side Test + + RMobileLine mobileLine; + CleanupClosePushL(mobileLine); + RMobileCall mobileCall; + CleanupClosePushL(mobileCall); + + RMobileLine mobileLine2; + CleanupClosePushL(mobileLine2); + RMobileCall mobileCall2; + CleanupClosePushL(mobileCall2); + + ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine, + mobileCall2, mobileLine2); + + RMobileConferenceCall confCall; + CleanupClosePushL(confCall); + + TRequestStatus notifyCall1Status; + RMobileCall::TMobileCallStatus call1Status; + mobileCall.NotifyMobileCallStatusChange(notifyCall1Status, call1Status); + + ClientCreateConferenceCallL(confCall); + + User::WaitForRequest(notifyCall1Status); + ASSERT_EQUALS(KErrNone, notifyCall1Status.Int()); + ASSERT_EQUALS(RMobileCall::EStatusConnected, call1Status); + + TRequestStatus oneToOneStatus; + mobileCall2.GoOneToOne(oneToOneStatus); + User::WaitForRequest(oneToOneStatus); + ASSERT_EQUALS(KErrNotSupported, oneToOneStatus.Int()); + + TInt numCalls; + ASSERT_EQUALS(KErrNone, confCall.EnumerateCalls(numCalls)); + ASSERT_EQUALS(2, numCalls); + + TRequestStatus hangupStatus; + confCall.HangUp(hangupStatus); + User::WaitForRequest(hangupStatus); + ASSERT_EQUALS(KErrNone, hangupStatus.Int()); + + mobileCall.Close(); + mobileCall2.Close(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(9, &config); + } + + +// +// Helper functions +// + +void CCTsyCallControlMultipartyFUNegative::DriverCreateConferenceCallL(RMobilePhone::TMobileService aMobileService, TInt aCallId1, TInt aCallId2) + { + RBuf8 data; + CleanupClosePushL(data); + + DriverDialAndHoldFirstCallDialSecondCallL(aMobileService, aCallId1, aCallId2); + + TMockLtsyData2 createConfData(aCallId1, aCallId2); + createConfData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlMultipartyCreateConference::KLtsyDispatchCallControlMultipartyCreateConferenceApiId, data); + + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 mockCallData( + aCallId1, RMobilePhone::EServiceUnspecified, callStatus); + data.Close(); + mockCallData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data); + + TMockLtsyCallData1 mockCallData2( + aCallId2, RMobilePhone::EServiceUnspecified, callStatus); + data.Close(); + mockCallData2.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data); + + CleanupStack::PopAndDestroy(1, &data); + } // CCTsyCallControlMultipartyFUNegative::DriverCreateConferenceCallL + +void CCTsyCallControlMultipartyFUNegative::DriverCreateConferenceCallAndHoldItL( + RMobilePhone::TMobileService aMobileService, TInt aCallId1, TInt aCallId2) + { + RBuf8 data; + CleanupClosePushL(data); + + DriverCreateConferenceCallL(aMobileService, aCallId1, aCallId2); + + // Swapping a conference call when there isn't another call causes hold + // IPC to go to the dispatcher. + DriverHoldCallL(aCallId1, KErrNone); + + // Call 2 which is part of the conference will go on hold + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusHold; + TMockLtsyCallData1 mockCallData( + aCallId2, RMobilePhone::EServiceUnspecified, callStatus); + data.Close(); + mockCallData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data); + + CleanupStack::PopAndDestroy(1, &data); + } // CCTsyCallControlMultipartyFUNegative::DriverCreateConferenceCallAndHoldItL + +void CCTsyCallControlMultipartyFUNegative::ClientCreateConferenceCallL(RMobileConferenceCall& aConfCall) + { + ASSERT_EQUALS(KErrNone, aConfCall.Open(iPhone)); + + RMobileConferenceCall::TMobileConferenceEvent confEvent; + TName callName; + TRequestStatus notifyConfEventStatus; + aConfCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, callName); + + TRequestStatus notifyConfStatus; + RMobileConferenceCall::TMobileConferenceStatus confStatus; + aConfCall.NotifyConferenceStatusChange(notifyConfStatus, confStatus); + + TRequestStatus createConfStatus; + aConfCall.CreateConference(createConfStatus); + + User::WaitForRequest(notifyConfEventStatus); + ASSERT_EQUALS(KErrNone, notifyConfEventStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, confEvent); // Call 1 when call status change notification completes + aConfCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, callName); + + User::WaitForRequest(notifyConfEventStatus); + ASSERT_EQUALS(KErrNone, notifyConfEventStatus.Int()); // Call 2 added when call status change notification completes + ASSERT_EQUALS(RMobileConferenceCall::EConferenceCallAdded, confEvent); + aConfCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, callName); + + User::WaitForRequest(notifyConfEventStatus); + ASSERT_EQUALS(KErrNone, notifyConfEventStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceBuilt, confEvent); + + User::WaitForRequest(notifyConfStatus); + ASSERT_EQUALS(KErrNone, notifyConfStatus.Int()); + ASSERT_EQUALS(RMobileConferenceCall::EConferenceActive, confStatus); + + User::WaitForRequest(createConfStatus); + ASSERT_EQUALS(KErrNone, createConfStatus.Int()); + } // CCTsyCallControlMultipartyFUNegative::ClientCreateConferenceCallL + +void CCTsyCallControlMultipartyFUNegative::ClientSwapConferenceCallL(RMobileConferenceCall& aConfCall, + RMobileConferenceCall::TMobileConferenceEvent aExpectedConfEvent, RMobileConferenceCall::TMobileConferenceStatus aExpectedConfStatus) + { + TRequestStatus notifyConfStatus; + RMobileConferenceCall::TMobileConferenceStatus confStatus; + aConfCall.NotifyConferenceStatusChange(notifyConfStatus, confStatus); + + RMobileConferenceCall::TMobileConferenceEvent confEvent; + TName callName; + TRequestStatus notifyConfEventStatus; + aConfCall.NotifyConferenceEvent(notifyConfEventStatus, confEvent, callName); + + TRequestStatus swapStatus; + aConfCall.Swap(swapStatus); + User::WaitForRequest(swapStatus); + ASSERT_EQUALS(KErrNone, swapStatus.Int()); + + User::WaitForRequest(notifyConfEventStatus); + ASSERT_EQUALS(KErrNone, notifyConfEventStatus.Int()); + ASSERT_EQUALS(aExpectedConfEvent, confEvent); + + User::WaitForRequest(notifyConfStatus); + ASSERT_EQUALS(KErrNone, notifyConfStatus.Int()); + ASSERT_EQUALS(aExpectedConfStatus, confStatus); + } // CCTsyCallControlMultipartyFUNegative::ClientSwapConferenceCallL + +void CCTsyCallControlMultipartyFUNegative::ClientCreateConferenceCallAndHoldItL( + RMobilePhone::TMobileService aMobileService, RMobileCall& aMobileCall, + RMobileLine& aMobileLine, RMobileCall& aMobileCall2, RMobileLine& aMobileLine2, + RMobileConferenceCall& aConfCall) + { + ClientDialAndHoldFirstCallDialSecondCallL(aMobileService, aMobileCall, aMobileLine, aMobileCall2, aMobileLine2); + ClientCreateConferenceCallL(aConfCall); + ClientSwapConferenceCallL(aConfCall, RMobileConferenceCall::EConferenceSwapped, RMobileConferenceCall::EConferenceHold); + } // CCTsyCallControlMultipartyFUNegative::ClientCreateConferenceCallAndHoldItL +