// 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 <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

#include "cmmconferencecalltsy.h"

#include <sys/unistd.h>

#include <etelmmerr.h>

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<TInt> 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<TInt> 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;