// 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:

//

/**

 @file The TEFUnit test suite for SetUpCall in the SAT.

*/

#include <cstktsy/bertlv_defs.h>

#include <etel.h>

#include <etelmm.h>

#include <satcs.h>

#include <ctsy/ltsy/sat_defs.h>

#include <ctsy/ltsy/mltsydispatchsatinterface.h>

#include <test/mockltsyindicatorids.h>

#include <test/tmockltsydata.h>

#include "ccsatsetupcallfu.h"

const TInt KDelay = 10;

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatSetUpCallFU, TestNotifySetUpCallPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatSetUpCallFU, TestNotifySetUpCallPCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatSetUpCallFU, TestNotifySetUpCallPCmd0004L);

	ADD_TEST_STEP_ISO_CPP(CCSatSetUpCallFU, TestNotifySetUpCallPCmd0001bL);

	ADD_TEST_STEP_ISO_CPP(CCSatSetUpCallFU, TestNotifySetUpCallPCmd0001cL);

	ADD_TEST_STEP_ISO_CPP(CCSatSetUpCallFU, TestNotifySetUpCallPCmd0001dL);

	ADD_TEST_STEP_ISO_CPP(CCSatSetUpCallFU, TestNotifySetUpCallPCmd0001eL);

	END_SUITE;

	}

void CCSatSetUpCallFU::PrepareTlvData ( TTlv& aTlvData,

		                                const TData& aData,

		                                const TDesC8& aAlphaIdentifier,

		                                const TDesC8& aSecondAlphaIdentifier )

	{

	aTlvData.Begin(KBerTlvProactiveSimCommandTag);

	aTlvData.AddTag(KTlvCommandDetailsTag);         // Command details

	aTlvData.AddByte(aData.iCommandNumber);               // Command number     

	aTlvData.AddByte(aData.iCommandType);                   // Command type     

	aTlvData.AddByte(aData.iCommandQualifier);            // Command qualifier  

	aTlvData.AddTag(KTlvDeviceIdentityTag);         // Device identities          

	aTlvData.AddByte(aData.iSourceDevice);                // Source device     

	aTlvData.AddByte(aData.iDestinationDevice);           // Destination device     

	if (aAlphaIdentifier.Length() > 0)

		{

		aTlvData.AddTag(KTlvAlphaIdentifierTag);        // Alpha identifier

		aTlvData.AddData(aAlphaIdentifier);

		}

	aTlvData.AddTag(KTlvAddressTag);                // Address

	aTlvData.AddByte(aData.iAddress);                // International, ISDN / telephone numbering plan

	TInt callNumberSize = aData.iCallNumber.Length();

	if (callNumberSize > 0)

		{

		for (TInt i = 0; i < callNumberSize; i++)

			{

			aTlvData.AddByte(aData.iCallNumber[i]);           

			}

		}

	TInt infoTransferCapSize = aData.iInfoTransferCap.Length();

	if (infoTransferCapSize > 0)

		{

		// Capability configuration parameters

		aTlvData.AddTag(KTlvCapabilityConfigurationParametersTag);

		for (TInt i = 0; i < infoTransferCapSize; i++)

			{

			aTlvData.AddByte(aData.iInfoTransferCap[i]);

			}

		}

	TInt subaddresSize = aData.iSubAddress.Length();

	if (subaddresSize > 0)

		{

		aTlvData.AddTag(KTlvSubaddressTag);

		for (TInt i = 0; i < subaddresSize; i++)

			{

			aTlvData.AddByte(aData.iSubAddress[i]);

			}

		}

	if ( aData.iDuration.iIfUse )

		{

		aTlvData.AddTag(KTlvDurationTag);

		aTlvData.AddByte(aData.iDuration.iUnit);

		aTlvData.AddByte(aData.iDuration.iInterval);

		}

	if ( aData.iIcon1.iIfUse )

		{

		aTlvData.AddTag(KTlvIconIdentifierTag);

		aTlvData.AddByte(aData.iIcon1.iQualifier);

		aTlvData.AddByte(aData.iIcon1.iIdentifier);

		}

	// This blocks are always called last.

	if (aSecondAlphaIdentifier.Length() > 0)

		{

		aTlvData.AddTag(KTlvAlphaIdentifierTag);

		aTlvData.AddData(aSecondAlphaIdentifier);

		}

	if ( aData.iIcon2.iIfUse )

		{

		aTlvData.AddTag(KTlvIconIdentifierTag);

		aTlvData.AddByte(aData.iIcon2.iQualifier);

		aTlvData.AddByte(aData.iIcon2.iIdentifier);

		}

	if ( aData.iTextAttribute1.iIfUse )

		{

		aTlvData.AddTag(KBerTlvProactiveSimCommandTag);

		aTlvData.AddByte(aData.iTextAttribute1.iFormattingPosition);

		aTlvData.AddByte(aData.iTextAttribute1.iFormattingLength);

		aTlvData.AddByte(aData.iTextAttribute1.iFormattingMode);

		aTlvData.AddByte(aData.iTextAttribute1.iColour);

		}

	if ( aData.iTextAttribute2.iIfUse )

		{

		aTlvData.AddTag(KBerTlvProactiveSimCommandTag);

		aTlvData.AddByte(aData.iTextAttribute2.iFormattingPosition);

		aTlvData.AddByte(aData.iTextAttribute2.iFormattingLength);

		aTlvData.AddByte(aData.iTextAttribute2.iFormattingMode);

		aTlvData.AddByte(aData.iTextAttribute2.iColour);

		}

	}

void CCSatSetUpCallFU::PrepareExpectDataL ( TUint8 aCommandType )

	{

	RBuf8 data;

	CleanupClosePushL(data);	

	TMockLtsyData1<TUint8> expLtsyData(aCommandType);

	expLtsyData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data);

	CleanupStack::PopAndDestroy(1); // data

	}

void CCSatSetUpCallFU::PrepareCompleteDataL ( const TData& aData,

		                                     const TDesC8& aAlphaIdentifier,

		                                     TInt aResultCode,

		                                     const TDesC8& aSecondAlphaIdentifier )

	{

	RBuf8 data;

	CleanupClosePushL(data);	

	TTlv tlv;

	PrepareTlvData( tlv, aData, aAlphaIdentifier, aSecondAlphaIdentifier );

	TPtrC8 tlvDsc = tlv.End();

	TDesC8* tlvDscPtr = &tlvDsc;

	TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);

	tlvDscPack.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, aResultCode, data, KDelay);

	CleanupStack::PopAndDestroy(1); // data

	}

void CCSatSetUpCallFU::ProactiveCommandCallL( RSat::TSetUpCallV6& aSetupCallData, 

		                                     const TData& aData,

		                                     const TDesC8& aAlphaIdentifier,

		                                     TInt aResultCode,

		                                     const TDesC8& aSecondAlphaIdentifier )

	{

	TRequestStatus requestStatus;

	PrepareExpectDataL ( aData.iCommandType );

	RSat::TSetUpCallV6Pckg setpPck(aSetupCallData);

	iSat.NotifySetUpCallPCmd(requestStatus, setpPck);

	PrepareCompleteDataL ( aData, aAlphaIdentifier, aResultCode, aSecondAlphaIdentifier );

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(aResultCode, requestStatus.Int());

	}

void CCSatSetUpCallFU::DataCompareL(const RSat::TSetUpCallV6& aSetupCallData,

		                           const TUint8 aCommandQualifier,

		                           const TDesC& aAlphaId,

		                           const RSat::TTypeOfNumber aTypeOfNumber,

		                           const RSat::TNumberingPlan aNumberPlan)

	{

	RSat::TSetUpCallType type;

    switch ( aCommandQualifier )

        {

        case KOnlyIfNotBusy:

            {

            // Set up call, if not busy on another call

            type = RSat::EOnlyIfNotBusy;

            break;

            }

        case KOnlyIfNotBusyWithRedial:

            {

            // Set up call, if not busy on another call, with redial

            type = RSat::EOnlyIfNotBusyWithRedial;

            break;

            }

        case KHoldOtherCalls:

            {

            // Set up call, put other calls (if any) on hold

            type = RSat::EHoldOtherCalls;

            break;

            }

        case KHoldOtherCallsWithRedial:

            {

            // Set up call, put other calls (if any) on hold, with 

            // redial

            type = RSat::EHoldOtherCallsWithRedial;

            break;

            }

        case KDisconnectOtherCalls:

            {

            // Set up call, disconnect other calls (if any)

            type = RSat::EDisconnectOtherCalls;

            break;

            }

        case KDisconnectOtherCallsWithRedial:

            {

            // Set up call, disconn. other calls (if any), with redial

            type = RSat::EDisconnectOtherCallsWithRedial;

            break;

            }

        default:

            {

            // Call type not set

            type = RSat::ESetUpCallTypeNotSet;

            break;

            }

        }

	ASSERT_EQUALS(type, aSetupCallData.iType);

	ASSERT_TRUE(0 == aSetupCallData.iAlphaIdConfirmationPhase.iAlphaId.Compare(aAlphaId));

	ASSERT_EQUALS(aTypeOfNumber, aSetupCallData.iAddress.iTypeOfNumber);

	ASSERT_EQUALS(aNumberPlan, aSetupCallData.iAddress.iNumberPlan);

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CSAT-SUC-SNSUCPC-0001

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpCallPCmd

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySetUpCallPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSetUpCallFU::TestNotifySetUpCallPCmd0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	TRequestStatus requestStatus;

	const TUint8 KAddress = 0x91; //10010001

	RSat::TSetUpCallV6 setupCallData;

	TData data;

	data.iCommandNumber = 1;

	data.iCommandQualifier = KSetUpCallIfNotCurrentlyBusy;

	data.iSourceDevice = KSim;

	data.iDestinationDevice = KNetwork;

	data.iAddress = KAddress;

	data.iCommandType = KSetUpCall;

	_LIT8(KAlphaIdentifier1, "Not busy");

	_LIT16(KAlphaIdentifier1_16, "Not busy");

	data.iCallNumber.Append(0x10);

	data.iCallNumber.Append(0x32);

	data.iCallNumber.Append(0x04);

	data.iCallNumber.Append(0x21);

	data.iCallNumber.Append(0x43);

	data.iCallNumber.Append(0x65);

	data.iCallNumber.Append(0x1C);

	data.iCallNumber.Append(0x2C);

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

	// TEST C: Successful completion request of

	// RSat::NotifySetUpCallPCmd 

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

	// test C - implemented in 0001b-0001d functions

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

	// TEST E: Coverage test(s) for RSat::NotifySetUpCallPCmd

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

	iMockLTSY.NotifyTerminated(requestStatus);

	PrepareCompleteDataL ( data, KAlphaIdentifier1 );

	RSat::TAdditionalInfo additionalInfo;

	additionalInfo.Append(KNoCause);

	PrepareTerminalResponseMockDataL( data.iCommandNumber, data.iCommandType, 

			data.iCommandQualifier, additionalInfo, RSat::KMeUnableToProcessCmd, KNullDesC8 );

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	AssertMockLtsyStatusL();

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

	// to increase CSatNotifySetUpCall::CompleteNotifyL coverage 

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

	PrepareExpectDataL ( data.iCommandType );

	RSat::TSetUpCallV6Pckg setpPck(setupCallData);

	iSat.NotifySetUpCallPCmd(requestStatus, setpPck);

	RBuf8 bufData;

	CleanupClosePushL(bufData);	

	TTlv tlv;

	tlv.Begin(KBerTlvProactiveSimCommandTag);

	tlv.AddTag(KTlvCommandDetailsTag);         // Command details

	tlv.AddByte(data.iCommandNumber);               // Command number     

	tlv.AddByte(data.iCommandType);                   // Command type     

	tlv.AddByte(data.iCommandQualifier);            // Command qualifier  

	tlv.AddTag(KTlvDeviceIdentityTag);         // Device identities          

	tlv.AddByte(data.iSourceDevice);                // Source device     

	tlv.AddByte(data.iDestinationDevice);           // Destination device     

	tlv.AddTag(KTlvAlphaIdentifierTag);

	tlv.AddTag(KTlvAlphaIdentifierTag);

	tlv.AddTag(KTlvAddressTag);

	tlv.AddTag(KTlvSubaddressTag);

	TPtrC8 tlvDsc = tlv.End();

	TDesC8* tlvDscPtr = &tlvDsc;

	TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);

	tlvDscPack.SerialiseL(bufData);

	iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, KErrNone, bufData, KDelay);

	PrepareTerminalResponseMockDataL( data.iCommandNumber, data.iCommandType, 

			data.iCommandQualifier, KNullDesC16, RSat::KCmdDataNotUnderstood, KNullDesC8 );

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrCorrupt, requestStatus.Int());

	AssertMockLtsyStatusL();

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

	// to increase CSatNotifySetUpCall::CompleteNotifyL coverage 

	// in case of  "command qualifier"

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

	const TUint8 KDefualtCommand = 0x7F;

	const TUint8 qualifierArray[] = { KHoldOtherCallsWithRedial, KDisconnectOtherCallsWithRedial, 

			                          KDefualtCommand };

	TUint8 sizeArray = sizeof(qualifierArray)/sizeof(qualifierArray[0]);

	RSat::TSetUpCallRspV2 resp;

	RSat::TSetUpCallRspV2Pckg respPck(resp);

	for ( TUint8 i = 0; i < sizeArray; i++ )

		{

		data.iCommandQualifier = qualifierArray[i];

		ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier1 );

		DataCompareL(setupCallData, 

				     data.iCommandQualifier, 

				     KAlphaIdentifier1_16,

				     RSat::EInternationalNumber,

				     RSat::EIsdnNumberPlan);

		resp.iInfoType = RSat::KNoAdditionalInfo;

		resp.iGeneralResult = RSat::KSuccess;

		CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType, 

				data.iCommandQualifier, RSat::ESetUpCall, respPck, resp.iAdditionalInfo, resp.iGeneralResult );

		AssertMockLtsyStatusL();

		}

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

	// TEST B: failure on completion of pending request from LTSY->CTSY

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

	ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier1, KErrGeneral);

	CleanupStack::PopAndDestroy(2, this); // this, bufData

	}

/**

@SYMTestCaseID BA-CSAT-SUC-SNSUCPC-0002

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for cancelling of RSat::NotifySetUpCallPCmd

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RSat::NotifySetUpCallPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSetUpCallFU::TestNotifySetUpCallPCmd0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	TUint8 commandType = KSetUpCall;

	TRequestStatus requestStatus;

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

	// Test cancelling of RSat::NotifySetUpCallPCmd

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

	PrepareExpectDataL ( commandType );

	RSat::TSetUpCallV6 setupCallData;

	RSat::TSetUpCallV6Pckg setupCallDataPck(setupCallData);

	iSat.NotifySetUpCallPCmd(requestStatus, setupCallDataPck);

	iSat.CancelAsyncRequest(ESatNotifySetUpCallPCmd);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(1, this); // this	

	}

/**

@SYMTestCaseID BA-CSAT-SUC-SNSUCPC-0004

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for multiple client requests to RSat::NotifySetUpCallPCmd

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RSat::NotifySetUpCallPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSetUpCallFU::TestNotifySetUpCallPCmd0004L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	// 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);