// 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 PlayTone 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 "ccsatplaytonefu.h"

static const TUint8 KCommandNumber = 1;

static const TUint8 KCommandType   = KPlayTone;

static const TUint8 KSourceDevice = KSim;

static const TUint8 KDestinationDevice = KEarpiece;

static const TUint8 KCmdQualifier = 0;

static const TInt KDelay = 10;

CCSatPlayToneFU::TData::TTone::TTone() 

	{

	Clear();

	}

void CCSatPlayToneFU::TData::TTone::Clear()

	{

	iTone = RSat::KToneNotSet;

	iIfUse = EFalse;

	}

CCSatPlayToneFU::TData::TDuration::TDuration()

	{

	Clear();

	}

void CCSatPlayToneFU::TData::TDuration::Clear()

	{

	iIfUse = EFalse;

	iTimeUnit = KTenthsOfSeconds+1;

	iNumOfUnits = 0;

	}

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatPlayToneFU, TestNotifyPlayTonePCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatPlayToneFU, TestNotifyPlayTonePCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatPlayToneFU, TestNotifyPlayTonePCmd0004L);

	ADD_TEST_STEP_ISO_CPP(CCSatPlayToneFU, TestNotifyPlayTonePCmd0001bL);

	END_SUITE;

	}

void CCSatPlayToneFU::PrepareTlvData ( TTlv& aTlvData, TBool aAlphaIdLengthCheck)

	{	

	aTlvData.Begin(KBerTlvProactiveSimCommandTag);

	aTlvData.AddTag(KTlvCommandDetailsTag);         // Command details

	aTlvData.AddByte(KCommandNumber);         // Command number     

	aTlvData.AddByte(KCommandType);           // Command type     

	aTlvData.AddByte(KCmdQualifier);      // Command qualifier  

	aTlvData.AddTag(KTlvDeviceIdentityTag);         // Device identities          

	aTlvData.AddByte(KSourceDevice);          // Source device     

	aTlvData.AddByte(KDestinationDevice);     // Destination device     

	if (iData.iAlphaId.Length() > 0 || aAlphaIdLengthCheck)

		{

		aTlvData.AddTag(KTlvAlphaIdentifierTag);        // Alpha identifier

		aTlvData.AddData(iData.iAlphaId);

		}

	if ( iData.iTone.iIfUse )

		{

		aTlvData.AddTag(KTlvToneTag);                      // Device identities          

		aTlvData.AddByte(iData.iTone.iTone);                     // Tone

		}

	if ( iData.iDuration.iIfUse )

		{

		aTlvData.AddTag(KTlvDurationTag);

		aTlvData.AddByte(iData.iDuration.iTimeUnit);

		aTlvData.AddByte(iData.iDuration.iNumOfUnits);

		}

	}

void CCSatPlayToneFU::PrepareExpectDataL ()

	{

	RBuf8 data;

	CleanupClosePushL(data);	

	TUint8 command = KPlayTone;

	TMockLtsyData1<TUint8> expLtsyData(command);

	expLtsyData.SerialiseL(data);

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

	CleanupStack::PopAndDestroy(1); // data

	}

void CCSatPlayToneFU::PrepareCompleteDataL ( TInt aResultCode, TBool aAlphaIdLengthCheck )

	{

	RBuf8 data;

	CleanupClosePushL(data);	

	TTlv tlv;

	PrepareTlvData( tlv, aAlphaIdLengthCheck );

	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 CCSatPlayToneFU::ProactiveCommandCallL( 

		RSat::TPlayToneV2& aPlayToneData,

		TInt aCompleteErrorCode,

		TInt aResultCode,

		TBool aAlphaIdLengthCheck)

	{

	TRequestStatus requestStatus;

	PrepareExpectDataL ();

	TPckg< RSat::TPlayToneV2 > setpPck(aPlayToneData);

	iSat.NotifyPlayTonePCmd(requestStatus, setpPck);

	PrepareCompleteDataL ( aCompleteErrorCode, aAlphaIdLengthCheck );

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(aResultCode, requestStatus.Int());

	}

void CCSatPlayToneFU::TerminalResponseCallL(

		const RSat& aSat,

		RSat::TPCmdResult aGeneralResult)

	{

	RSat::TPlayToneRspV1 playToneRspV2;

	RSat::TPlayToneRspV1Pckg playToneRspV2Pckg(playToneRspV2);

	TRequestStatus requestStatus;

	playToneRspV2.iGeneralResult = aGeneralResult;

	playToneRspV2.SetPCmdNumber(KCommandNumber);

	playToneRspV2.iInfoType = RSat::KNoAdditionalInfo;

	PrepareTerminalResponseMockDataL(

			KCommandNumber,

			KCommandType,

			KCmdQualifier,

			KNullDesC16,

			playToneRspV2.iGeneralResult,

			KNullDesC8);

	aSat.TerminalRsp(requestStatus, RSat::EPlayTone, playToneRspV2Pckg);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	}

void CCSatPlayToneFU::DataInitialization(

		const TData::TTone& aTone,

		const TData::TDuration& aDuration,

		const TDesC8& aAlphaId)

	{

	iData.iAlphaId.Copy(aAlphaId);

	iData.iDuration = aDuration;

	iData.iTone = aTone;

	}

void CCSatPlayToneFU::DataCompareL( const RSat::TPlayToneV2& aPlayToneData )

{

	RSat::TAlphaIdBuf alphaId;

	alphaId.Copy(iData.iAlphaId);

	ASSERT_EQUALS( 0, alphaId.Compare( aPlayToneData.iAlphaId.iAlphaId ) );

	TUint8 durationTimeUnit;

	switch ( aPlayToneData.iDuration.iTimeUnit )

		{

		case RSat::EMinutes:

			{

			// Minutes

			durationTimeUnit = KMinutes;

			break;

			}

		case RSat::ESeconds:

			{

			// Seconds

			durationTimeUnit = KSeconds;

			break;

			}

		case RSat::ETenthsOfSeconds:

			{

			// Tenths of seconds

			durationTimeUnit = KTenthsOfSeconds;

			break;

			}

		default:

			{

			durationTimeUnit = KTenthsOfSeconds+1;

			}

		}

	ASSERT_EQUALS( iData.iDuration.iTimeUnit, durationTimeUnit);

	ASSERT_EQUALS( iData.iDuration.iNumOfUnits, aPlayToneData.iDuration.iNumOfUnits );

	ASSERT_EQUALS( iData.iTone.iTone, aPlayToneData.iTone );

}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CSAT-PTON-SNPTPC-0001

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for RSat::NotifyPlayTonePCmd

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifyPlayTonePCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatPlayToneFU::TestNotifyPlayTonePCmd0001L()

	{

	static const RSat::TPCmdResult KGenResultArray[] = {

			RSat::KBackwardModeRequestedByUser,

			RSat::KNoResponseFromUser,

			RSat::KErrorRequiredValuesMissing,

			RSat::KHelpRequestedByUser,

			RSat::KCmdDataNotUnderstood,

			RSat::KCmdBeyondMeCapabilities,

			RSat::KMeUnableToProcessCmd };

	const TInt KSize = sizeof(KGenResultArray)/sizeof(KGenResultArray[0]);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	TRequestStatus requestStatus;

	RSat::TPlayToneV2 playToneData;

	TData::TTone tone;

	TData::TDuration duration;

	DataInitialization(tone, duration);

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

	// TEST C: Successful completion request of

	// RSat::NotifyPlayTonePCmd 

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

	// test C - implemented in 0001b function

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

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

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

	iMockLTSY.NotifyTerminated(requestStatus);

	PrepareCompleteDataL ();

	RSat::TAdditionalInfo additionalInfo;

	additionalInfo.Append(KNoCause);

	PrepareTerminalResponseMockDataL(

			KCommandNumber,

			KCommandType,

			KCmdQualifier,

			additionalInfo,

			RSat::KMeUnableToProcessCmd,

			KNullDesC8);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	AssertMockLtsyStatusL();

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

	// to increase CSatNotifyPlayTone::CompleteNotifyL coverage 

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

	ProactiveCommandCallL(playToneData, KErrNone, KErrNone, ETrue);

	AssertMockLtsyStatusL();

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

	// to increase CSatNotifyPlayTone::CompleteNotifyL coverage 

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

	RSat::TPlayToneRspV1 playToneRspV2;

	RSat::TPlayToneRspV1Pckg playToneRspV2Pckg(playToneRspV2);

	additionalInfo.Zero();

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

		{

		ProactiveCommandCallL(playToneData);

		playToneRspV2.iGeneralResult = KGenResultArray[i];

		playToneRspV2.SetPCmdNumber(KCommandNumber);

		playToneRspV2.iInfoType = RSat::KNoAdditionalInfo;

		RSat::TPCmdResult element = KGenResultArray[i];

		if ( RSat::KCmdBeyondMeCapabilities == element ||

			 RSat::KMeUnableToProcessCmd == element )

			{

			additionalInfo.Zero();

			additionalInfo.Append(KNoCause);

			}

		PrepareTerminalResponseMockDataL(

				KCommandNumber, 

				KCommandType, 

				KCmdQualifier, 

				additionalInfo, 

				playToneRspV2.iGeneralResult,

				KNullDesC8);

		iSat.TerminalRsp(requestStatus, RSat::EPlayTone, playToneRspV2Pckg);

		User::WaitForRequest(requestStatus);

		if ( RSat::KCmdDataNotUnderstood == element ||

			 RSat::KCmdBeyondMeCapabilities == element ||

			 RSat::KMeUnableToProcessCmd == element )

			{

			ASSERT_EQUALS(KErrNone, requestStatus.Int());

			}

		else

			{

			ASSERT_EQUALS(KErrCorrupt, requestStatus.Int());

			}

		AssertMockLtsyStatusL();

		}

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

	// to increase CSatNotifyPlayTone::CompleteNotifyL coverage 

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

	playToneRspV2.iGeneralResult = RSat::KSuccess;

	playToneRspV2.SetPCmdNumber(KCommandNumber);

	playToneRspV2.iInfoType = RSat::KMeProblem;

	PrepareTerminalResponseMockDataL(

			KCommandNumber, 

			KCommandType, 

			KCmdQualifier, 

			KNullDesC16, 

			playToneRspV2.iGeneralResult,

			KNullDesC8);

	iSat.TerminalRsp(requestStatus, RSat::EPlayTone, playToneRspV2Pckg);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrCorrupt, requestStatus.Int());

	AssertMockLtsyStatusL();

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

	// to increase CSatNotifyPlayTone::CompleteNotifyL coverage 

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

	playToneRspV2.iAdditionalInfo.Append( KNoCause );

	PrepareTerminalResponseMockDataL(

			KCommandNumber, 

			KCommandType, 

			KCmdQualifier, 

			KNullDesC16, 

			playToneRspV2.iGeneralResult,

			KNullDesC8);

	iSat.TerminalRsp(requestStatus, RSat::EPlayTone, playToneRspV2Pckg);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	AssertMockLtsyStatusL();

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

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

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

	ProactiveCommandCallL( playToneData, KErrUnknown, KErrUnknown);

	AssertMockLtsyStatusL();

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

	}

/**

@SYMTestCaseID BA-CSAT-PTON-SNPTPC-0002

@SYMPREQ 1780

@SYMComponent  telephony_csat

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

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RSat::NotifyPlayTonePCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatPlayToneFU::TestNotifyPlayTonePCmd0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	TRequestStatus requestStatus;

	RSat::TPlayToneV2 playToneV2;

	RSat::TPlayToneV2Pckg playToneV2Pck(playToneV2);

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

	// Test cancelling of RSat::NotifyPlayTonePCmd

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

	PrepareExpectDataL();

	iSat.NotifyPlayTonePCmd(requestStatus, playToneV2Pck);

	iSat.CancelAsyncRequest(ESatNotifyPlayTonePCmd);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(1); // this

	}

/**

@SYMTestCaseID BA-CSAT-PTON-SNPTPC-0004

@SYMPREQ 1780

@SYMComponent  telephony_csat

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

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RSat::NotifyPlayTonePCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatPlayToneFU::TestNotifyPlayTonePCmd0004L()

	{

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

	RSat sat2;

	ret = sat2.Open(phone2);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(sat2);

	TRequestStatus requestStatus1;

	TRequestStatus requestStatus2;

	_LIT8(KText, "Dial Tone"); 

	TData::TTone tone;

	TData::TDuration duration;

	DataInitialization(tone, duration, KText);

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

	// Test A: Test multiple clients requesting RSat::NotifyPlayTonePCmd

	// when they both pass the same T-class version

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

	PrepareExpectDataL();

	RSat::TPlayToneV2 playTone1;

	RSat::TPlayToneV2Pckg playTonePck1(playTone1);

	iSat.NotifyPlayTonePCmd(requestStatus1, playTonePck1);

	RSat::TPlayToneV2 playTone2;

	RSat::TPlayToneV2Pckg playTonePck2(playTone2);

	sat2.NotifyPlayTonePCmd(requestStatus2, playTonePck2);

	PrepareCompleteDataL();

	User::WaitForRequest(requestStatus1);

	User::WaitForRequest(requestStatus2);

	ASSERT_EQUALS(KErrNone, requestStatus1.Int());

	//probably «KErrServerBusy?is more appropriate result here

	ASSERT_EQUALS(KErrNone, requestStatus2.Int());

	TerminalResponseCallL(iSat);

	TerminalResponseCallL(sat2);

	DataCompareL( playTone1 );

	DataCompareL( playTone2 );

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this); // sat2, phone2, telServer2, this

	}