// 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 CallOwnership in the Common TSY.

// 

//

/**

 @file 

*/

#include "cctsycallownershipfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

CTestSuite* CCTsyCallOwnershipFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestLoanDataPort0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestLoanDataPort0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestLoanDataPort0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestLoanDataPort0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestLoanDataPort00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestRecoverDataPort0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestRecoverDataPort0006L);

    ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestRecoverDataPort0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestRecoverDataPort00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestAcquireOwnership0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestAcquireOwnership0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestAcquireOwnership0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestAcquireOwnership0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestAcquireOwnership00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestTransferOwnership0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestTransferOwnership0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallOwnershipFU, TestTransferOwnership00011L);

	END_SUITE;

	}

/**

Test support failure in CTSY for RCall::LoanDataPort

@param aName The name of the line from which the call is to be opened to test for RCall::LoanDataPort

@param aCallId callId ltsy must allocate for the call

*/

void CCTsyCallOwnershipFU::TestLoanDataPortNotSupportedL(const TDesC &aName, const TInt aCallId)

	{

	RCall call;

	RLine line;

	TInt err = line.Open(iPhone, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(line);

	err = OpenNewCall(line, call, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call);

	RMobilePhone::TMobileService mobileService( RMobilePhone::EServiceUnspecified );

	if ( aName == KMmTsyVoice1LineName )

		{

		mobileService = RMobilePhone::EVoiceService;

		}

	else if ( aName == KMmTsyVoice2LineName )

		{

		mobileService = RMobilePhone::EAuxVoiceService;

		}

	else if ( aName == KMmTsyFaxLineName )

		{

		mobileService = RMobilePhone::EFaxService;

		}

	if ( (mobileService == RMobilePhone::EVoiceService) ||

			(mobileService == RMobilePhone::EAuxVoiceService) )

		{

		DialL(call, aCallId, mobileService);

		}

	// synchronous version testing

	RCall::TCommPort dataPort;

	dataPort.iCsy.Copy(_L("qwerty"));

	dataPort.iPort.Copy(_L("asdfgh"));

	err = call.LoanDataPort(dataPort);

	ASSERT_EQUALS(KErrNotSupported, err)

	AssertMockLtsyStatusL();

	// asynchronous version testing

	TRequestStatus reqStatus;

	call.LoanDataPort(reqStatus, dataPort);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

	CleanupStack::PopAndDestroy(2); //call, line

	AssertMockLtsyStatusL();

	}

/**

Test support failure in CTSY for RCall::RecoverDataPort

@param aName The name of the line from which the call is to be opened to test for RCall::RecoverDataPort

*/

void CCTsyCallOwnershipFU::TestRecoverDataPortNotSupportedL(const TDesC &aName)

	{

	RCall call;

	RLine line;

	TInt err = line.Open(iPhone, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(line);

	err = OpenNewCall(line, call, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call);

	err = call.RecoverDataPort();

	ASSERT_EQUALS(KErrNotSupported, err)

	CleanupStack::PopAndDestroy(2); // call, line

	AssertMockLtsyStatusL();

	}

/**

Test support failure in CTSY for RCall::AcquireOwnership

@param aName The name of the line from which the call is to be opened to test for RCall::AcquireOwnership

*/

void CCTsyCallOwnershipFU::TestAcquireOwnershipNotSupportedL(const TDesC &aName)

	{

	RCall call;

	RLine line;

	TInt err = line.Open(iPhone, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(line);

	err = OpenNewCall(line, call, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call);

	TRequestStatus reqStatus;

	call.AcquireOwnership(reqStatus);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

	CleanupStack::PopAndDestroy(2); // call, line

	AssertMockLtsyStatusL();

	}

/**

Test support failure in CTSY for RCall::TransferOwnership

@param aName The name of the line from which the call is to be opened to test for RCall::TransferOwnership

*/

void CCTsyCallOwnershipFU::TestTransferOwnershipNotSupportedL(const TDesC &aName)

	{

	RCall call;

	RLine line;

	TInt err = line.Open(iPhone, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(line);

	err = OpenNewCall(line, call, aName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call);

	err = call.TransferOwnership();

	ASSERT_EQUALS(KErrNotSupported, err)

	CleanupStack::PopAndDestroy(2); // call, line

	AssertMockLtsyStatusL();

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-COWN-CLDP-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RCall::LoanDataPort for voice calls

@SYMTestPriority High

@SYMTestActions Invokes RCall::LoanDataPort for voice calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallOwnershipFU::TestLoanDataPort0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	TestLoanDataPortNotSupportedL(KMmTsyVoice1LineName, 1);

	TestLoanDataPortNotSupportedL(KMmTsyVoice2LineName, 2);

	CleanupStack::PopAndDestroy(this);

	}

/**

@SYMTestCaseID BA-CTSY-COWN-CLDP-0006

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RCall::LoanDataPort for data calls

@SYMTestPriority High

@SYMTestActions Invokes RCall::LoanDataPort for data calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallOwnershipFU::TestLoanDataPort0006L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RCall call;

	RLine line;

	TInt err = line.Open(iPhone, KMmTsyDataLineName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(line);

	TName callName;

	err = OpenNewCall(line, call, KMmTsyDataLineName, callName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call);

	// Prepare data

	TInt callId = 0;

	RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	RCall::TCommPort expDataPort;

	expDataPort.iCsy.Copy(_L("qwerty"));

	expDataPort.iPort.Copy(_L("asdfgh"));

	TMockLtsyCallData1<RCall::TCommPort> expData1(callId, mobileService, expDataPort);

	callId = 1;

	TMockLtsyCallData1<RCall::TCommPort> expData2(callId, mobileService, expDataPort);	

	RCall::TCommPort dataPort;

	dataPort.iCsy.Copy(expDataPort.iCsy);

	dataPort.iPort.Copy(expDataPort.iPort);

	TRequestStatus reqStatus;

	//-------------------------------------------------------------------------

	// Test: failure to dispatch request to CTSY when call is not active

	//-------------------------------------------------------------------------

    // Basically succeeding of LoanDataPort() request depends from LTSY.

    // Probably LTSY returns error to LoanDataPort() request when data call is

    // not active. But in theory also KErrNone is possible.  

	// Synchronous version testing. LTSY returns KErrNone.

	expData1.SerialiseL(data); 

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data, KErrNone);

	err = call.LoanDataPort(dataPort);

	ASSERT_EQUALS(KErrNone, err)

	AssertMockLtsyStatusL(); 

	// Asynchronous version testing. Fails because data port is already loaned.

	call.LoanDataPort(reqStatus, dataPort);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrEtelPortAlreadyLoaned, reqStatus.Int())

	AssertMockLtsyStatusL();

	// Recover data port before next test phase.

	iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data, KErrNone);

	err = call.RecoverDataPort();

	ASSERT_EQUALS(KErrNone, err)

	AssertMockLtsyStatusL();       

	// Synchronous version testing. LTSY returns error KErrEtelCallNotActive.   

    iMockLTSY.ExpectL(EEtelCallLoanDataPort, data, KErrEtelCallNotActive);  	

	err = call.LoanDataPort(dataPort);

	ASSERT_EQUALS(KErrEtelCallNotActive, err)

	AssertMockLtsyStatusL();	

	// Asynchronous version testing. LTSY returns error KErrEtelCallNotActive.

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data, KErrEtelCallNotActive); 

	call.LoanDataPort(reqStatus, dataPort);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrEtelCallNotActive, reqStatus.Int())

	AssertMockLtsyStatusL();

	// Close data call. After this CCallBase should call CTSY's RelinquishOwnership()

	// method instead of RecoverDataPortAndRelinquishOwnership().		

	CleanupStack::PopAndDestroy(1); // call

	// Open data call again.

	err = OpenNewCall(line, call, KMmTsyDataLineName, callName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call);		                  	

 	//-------------------------------------------------------------------------

	// TEST A: failure to dispatch request to LTSY

 	//-------------------------------------------------------------------------

    callId = 1;

	DialL(call, callId, mobileService);

	data.Close();

	expData2.SerialiseL(data);

	// Synchronous version testing. LTSY returns error KErrNotSupported.

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data, KErrNotSupported);

	err = call.LoanDataPort(dataPort);

	ASSERT_EQUALS(KErrNotSupported, err)

	AssertMockLtsyStatusL();

	// Asynchronous version testing. LTSY returns error KErrNotSupported.

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data, KErrNotSupported);

	call.LoanDataPort(reqStatus, dataPort);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST C: Successful completion request of

	// RCall::LoanDataPort.

 	//-------------------------------------------------------------------------

	// Synchronous version testing. LTSY returns KErrNone.

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);

	err = call.LoanDataPort(dataPort);

	ASSERT_EQUALS(KErrNone, err)

	AssertMockLtsyStatusL();

	// Turn back environment state.

	iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);

	err = call.RecoverDataPort();

	ASSERT_EQUALS(KErrNone, err)

	AssertMockLtsyStatusL();

	// Asynchronous version testing. LTSY returns KErrNone.

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);

	call.LoanDataPort(reqStatus, dataPort);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNone, reqStatus.Int())

	AssertMockLtsyStatusL();

	// Turn back environment state.

	iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);

	err = call.RecoverDataPort();

	ASSERT_EQUALS(KErrNone, err)

	AssertMockLtsyStatusL();

	//-------------------------------------------------------------------------

	// TEST: failure to dispatch request to CTSY

	// when call is owned by other client

 	//-------------------------------------------------------------------------

	// Open second client.

	RTelServer telServer2;

	err = telServer2.Connect();

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(telServer2);

	RMobilePhone phone2;

	err = phone2.Open(telServer2, KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, err);

	CleanupClosePushL(phone2);

	RCall call2;

	RLine line2;

	err = line2.Open(phone2, KMmTsyDataLineName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(line2);

	err = call2.OpenExistingCall(line2, callName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call2);

	// Try to loan data port when call is owned by other client.

	err = call2.LoanDataPort(dataPort);

	ASSERT_EQUALS(KErrEtelNotCallOwner, err)

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST: failure to dispatch request to CTSY when port is already loaned.

 	//-------------------------------------------------------------------------

	// Loan data port.

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);

	err = call.LoanDataPort(dataPort);

	ASSERT_EQUALS(KErrNone, err)

	AssertMockLtsyStatusL();

	// Try to loan data port when the port is loaned by other client.

	call.LoanDataPort(reqStatus, dataPort);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrEtelPortAlreadyLoaned, reqStatus.Int())

	AssertMockLtsyStatusL();

	iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data, KErrNone);

	CleanupStack::PopAndDestroy(8, this); // call2, line2, phone2, telServer2, 

	                                      // call, line, data, this	

	}

/**

@SYMTestCaseID BA-CTSY-COWN-CLDP-0007

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::LoanDataPort for data calls

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RCall::LoanDataPort for data calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallOwnershipFU::TestLoanDataPort0007L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RCall call;

	RLine line;

	TInt err = line.Open(iPhone, KMmTsyDataLineName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(line);

	err = OpenNewCall(line, call, KMmTsyDataLineName);

	ASSERT_EQUALS(KErrNone, err)

	CleanupClosePushL(call);

	// prepare data

	const TInt KCallId( 1 );

	const RMobilePhone::TMobileService KMobileService( RMobilePhone::ECircuitDataService );

	RCall::TCommPort expDataPort;

	expDataPort.iCsy.Copy(_L("qwerty"));

	expDataPort.iPort.Copy(_L("asdfgh"));

	TMockLtsyCallData1<RCall::TCommPort> expData(KCallId, KMobileService, expDataPort);

	expData.SerialiseL(data);

	RCall::TCommPort dataPort;

	dataPort.iCsy.Copy(expDataPort.iCsy);

	dataPort.iPort.Copy(expDataPort.iPort);

	TRequestStatus reqStatus;

	DialL(call, KCallId, KMobileService);

	//-------------------------------------------------------------------------

	// Test cancelling of RCall::LoanDataPort

 	//-------------------------------------------------------------------------

	iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);

	call.LoanDataPort(reqStatus, dataPort);

	call.LoanDataPortCancel();

	User::WaitForRequest(reqStatus);

	// cause cancel is not used in CTSY for this request

	// it completes with KErrNone

	ASSERT_EQUALS(KErrNone, reqStatus.Int())

	AssertMockLtsyStatusL();

	iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data, KErrNone);