// 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 SendReceiveData in the SAT.

*/

#include "ccsatsendreceivedatafu.h"

#include <etel.h>

#include <etelmm.h>

#include <satcs.h>

#include <test/tmockltsydata.h>

// define used constants

const TUint8 KSendDataStoreMode = 0x00; // constant for store mode

const TUint8 KReceiveDataQualifier = 0x00; // RFU

const TUint8 KIconOne = 1; // record 1 in EFIMG file on sim

const TUint8 KChannelDataLength = 200; // should be non zero

// additional information for RSat::KNetworkUnableToProcessCmd error

// in processing proactive command

// please see documentation for RSat::KNetworkUnableToProcessCmd

const TUint8 KRequestedFacilityNotImplemented = 69/*see 3GPP TS 24.008*/ | 0x80;

// define some channel data

_LIT8(KChannelData, "\x00\x01\x02\x03\x04\x05\x06\x07");

_LIT8(KBasicIconAlpha, "Basic Icon");

//"Hello" in Russian, first byte "\x80" is 0x80 UCS2 coding type for Tlv data

_LIT8(KRussianHello, "\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\

\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15");

//"Hello" in Russian in unicode for checking results

_LIT16(KRussianHelloU, "\x0417\x0414\x0420\x0410\x0412\x0421\x0422\x0412\

\x0423\x0419\x0422\x0415");

//"Hello" in Chinese, first byte "\x80" is 0x80 UCS2 coding type for Tlv data

_LIT8(KChineseHello, "\x80\x4F\x60\x59\x7D");

//"Hello" in Chinese in unicode for checking results

_LIT16(KChineseHelloU, "\x4F60\x597D");

//Characters in Katakana, first byte "\x80" is 0x80 UCS2 coding type for Tlv data

_LIT8(KKatakanaChars, "\x80\x30\xEB");

//Characters in Katakana in unicode for checking results

_LIT16(KKatakanaCharsU, "\x30EB");

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifyReceiveDataPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifyReceiveDataPCmd0001bL);

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifyReceiveDataPCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifyReceiveDataPCmd0004L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifySendDataPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifySendDataPCmd0001bL);

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifySendDataPCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendReceiveDataFU, TestNotifySendDataPCmd0004L);

	END_SUITE;

	}

/**

Fills in channel data descriptor

@param aData TDes8 or TDes16 descriptor data to be prepared

*/

template <class T>

LOCAL_C void PrepareChannelData(T& aData)

	{

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

		{

		aData.Append(i);

		}

	}

/**

Resets RSat::SendDataV2 data fields

@param aSendData data to be reset

*/

LOCAL_C void ResetSendData(RSat::TSendDataV2& aData)

	{

	// reset public members

	aData.iDestination = RSat::KDeviceIdNotSet;

	aData.iMode = RSat::ESendDataModeNotSet;

	aData.iAlphaId.iStatus = RSat::EAlphaIdNotSet;

	aData.iAlphaId.iAlphaId.Zero();

	aData.iIconId.iQualifier = RSat::EIconQualifierNotSet;

	aData.iIconId.iIdentifier = 0;

	aData.iChannelData.Zero();

	// reset protected members;

	aData.SetPCmdNumber(0);

	}

/**

Resets RSat::ReceiveDataV2 data fields

@param aReceiveData data to be reset

*/

LOCAL_C void ResetReceiveData(RSat::TReceiveDataV2& aData)

	{

	// reset public members

	aData.iDestination = RSat::KDeviceIdNotSet;

	aData.iAlphaId.iStatus = RSat::EAlphaIdNotSet;

	aData.iAlphaId.iAlphaId.Zero();

	aData.iIconId.iQualifier = RSat::EIconQualifierNotSet;

	aData.iIconId.iIdentifier = 0;

	aData.iChannelDataLength = 0;

	// reset protected members;

	aData.SetPCmdNumber(0);

	}

/**

Prepares SendData proactive command complete data for MockLtsy

@param aChannelData Channel data

@param aDelay Delay value for MockLtsy completion

*/

void CCSatSendReceiveDataFU::PrepareSendDataCompleteDataL(

		const TDesC8* aChannelData,

		TInt aDelay)

	{

	PrepareSendDataCompleteDataL(

			aChannelData, KPCmdNumberOne, KBipSendDataImmediately, RSat::KChannel1,

			NULL, RSat::EIconQualifierNotSet, KErrNone, aDelay);

	}

/**

Prepares SendData proactive command complete data for MockLtsy

@param aChannelData Channel data

@param aPCmdNumber Proactive command number.

@param aCmdQual Command qualifier

@param aDestDeviceId Command destination device Id

@param aAlphaId Alpha identifier

@param aIconQual Type of icon

@param aResult Proactive command notify result

@param aDelay Delay value for MockLtsy completion

*/

void CCSatSendReceiveDataFU::PrepareSendDataCompleteDataL(

		const TDesC8* aChannelData,

		TUint8 aPCmdNumber,

		TUint8 aCmdQual,

		TUint8 aDestDeviceId,

		const TDesC8* aAlphaId,

		RSat::TIconQualifier aIconQual,

		TInt aResult,

		TInt aDelay)

	{

	TTlv tlv;

	ProactiveCmdTlvBegin(tlv, aPCmdNumber, KSendData, aCmdQual, aDestDeviceId);

	if ( aChannelData )

		{

		tlv.AddTag(KTlvChannelDataTag);

		tlv.AddData(*aChannelData);//ETLV_ChannelDataString

		}

	if ( aAlphaId )

		{			

		tlv.AddTag(KTlvAlphaIdentifierTag);

		tlv.AddData(*aAlphaId);//ETLV_AlphaIdentifier

		}

	if ( ( RSat::ESelfExplanatory == aIconQual ) ||

			( RSat::ENotSelfExplanatory == aIconQual ) )

		{

		tlv.AddTag(KTlvIconIdentifierTag);

		tlv.AddByte((RSat::ESelfExplanatory == aIconQual)?0:1);//ETLV_IconQualifier

		tlv.AddByte(KIconOne);//ETLV_IconIdentifier

		}

	PrepareMockWithCompleteDataForPCmdNotifyL(tlv.End(), aResult, aDelay);

	}

/**

Tests for successful completion of RSat::NotifySendDataPCmd request

@param aChannelData Channel data

@param aCmdQual Command qualifier

*/

void CCSatSendReceiveDataFU::TestNotifySendDataPCmdL(

		const TDesC8* aChannelData,

		TUint8 aCmdQual)

	{

	TestNotifySendDataPCmdL(

			aChannelData, KPCmdNumberOne, aCmdQual, RSat::KChannel1,

			NULL, RSat::EIconQualifierNotSet, KErrNone, NULL);

	}

/**

Tests for completion of RSat::NotifySendDataPCmd request

@param aChannelData Channel data

@param aError Proactive command notify error code for mock data

*/

void CCSatSendReceiveDataFU::TestNotifySendDataPCmdErrorL(

		const TDesC8* aChannelData,

		TInt aError)

	{

	TestNotifySendDataPCmdL(

			aChannelData, KPCmdNumberOne, KBipSendDataImmediately, RSat::KChannel1,

			NULL, RSat::EIconQualifierNotSet, aError, NULL);

	}

/**

Tests for successful completion of RSat::NotifySendDataPCmd request

@param aChannelData Channel data

@param aDestDeviceId Command destination device Id

*/

void CCSatSendReceiveDataFU::TestNotifySendDataPCmdL(

		const TDesC8* aChannelData,

		RSat::TDeviceId aDestDeviceId)

	{

	TestNotifySendDataPCmdL(

			aChannelData, KPCmdNumberOne, KBipSendDataImmediately, aDestDeviceId,

			NULL, RSat::EIconQualifierNotSet, KErrNone, NULL);

	}

/**

Tests for successful completion of RSat::NotifySendDataPCmd request

@param aChannelData Channel data

@param aAlphaId Alpha identifier

@param aAlphaIdCheck Alpha identifier value to ckeck with returned value

@param aIconQual Type of icon

*/

void CCSatSendReceiveDataFU::TestNotifySendDataPCmdL(

		const TDesC8* aChannelData,

		const TDesC8* aAlphaId,

		const TDesC16* aAlphaIdCheck,

		RSat::TIconQualifier aIconQual)

	{

	TestNotifySendDataPCmdL(

			aChannelData, KPCmdNumberOne, KBipSendDataImmediately, RSat::KChannel1,

			aAlphaId, aIconQual, KErrNone, aAlphaIdCheck);

	}

/**

Tests for completion of RSat::NotifySendDataPCmd request

@param aChannelData Channel data

@param aPCmdNumber Proactive command number

@param aCmdQual Command qualifier

@param aDestDeviceId Command destination device Id

@param aAlphaId Alpha identifier

@param aIconQual Type of icon

@param aResult Proactive command notify result

@param aAlphaIdCheck Alpha identifier value to ckeck with returned value

*/

void CCSatSendReceiveDataFU::TestNotifySendDataPCmdL(

		const TDesC8* aChannelData,

		TUint8 aPCmdNumber,

		TUint8 aCmdQual,

		RSat::TDeviceId aDestDeviceId,

		const TDesC8* aAlphaId,

		RSat::TIconQualifier aIconQual,

		TInt aResult,

		const TDesC16* aAlphaIdCheck)

	{

	// write expected notify request in mockLtsy

	PrepareMockWithExpDataForPCmdNotifyL(KSendData);

	// write completion data in mockLtsy to complete notify request

	TUint8 destDeviceId = ( RSat::KDeviceIdNotSet==aDestDeviceId )?KDeviceIdNotSet:aDestDeviceId;

	PrepareSendDataCompleteDataL(

			aChannelData, aPCmdNumber, aCmdQual, destDeviceId,

			aAlphaId, aIconQual, aResult);

	// send notify request to CSAT

	RSat::TSendDataV2 sendData;

	RSat::TSendDataV2Pckg sendDataPckg(sendData);

	TRequestStatus requestStatus;

	iSat.NotifySendDataPCmd(requestStatus, sendDataPckg);

	// wait for the request completion

	User::WaitForRequest(requestStatus);

	// check expected results with recieved data

	ASSERT_EQUALS(aResult, requestStatus.Int());

	if ( KErrNone == aResult )

		{

		// proactive command number

		ASSERT_EQUALS(aPCmdNumber, sendData.PCmdNumber());

		ASSERT_EQUALS(aDestDeviceId, sendData.iDestination);

		if ( KBipSendDataImmediately & aCmdQual )

			{

			ASSERT_EQUALS(RSat::ESendDataImmediately, sendData.iMode);

			}

		else

			{

			ASSERT_EQUALS(RSat::EStoreDataInTxBuffer, sendData.iMode);

			}

		if ( aChannelData )

			{

			ASSERT_EQUALS( 0, aChannelData->Compare(sendData.iChannelData) );

			}

		else

			{

			ASSERT_EQUALS( 0, KNullDesC8().Compare(sendData.iChannelData) );

			}

		if ( aAlphaId && ( 0 < aAlphaId->Length() ) )

			{

			ASSERT_EQUALS(RSat::EAlphaIdProvided, sendData.iAlphaId.iStatus);

			if ( aAlphaIdCheck )

				{

				ASSERT_EQUALS( 0, aAlphaIdCheck->Compare(

						sendData.iAlphaId.iAlphaId));

				}

			else

				{

				ASSERT_EQUALS(0, Compare16bitDesWith8bitDesL(

												*aAlphaId,

												sendData.iAlphaId.iAlphaId));

				}

			}

		else if ( aAlphaId && ( 0 == aAlphaId->Length() ) )

			{

			ASSERT_EQUALS( RSat::EAlphaIdNull, sendData.iAlphaId.iStatus );

			}

		else

			{

			ASSERT_TRUE( (RSat::EAlphaIdNotPresent == sendData.iAlphaId.iStatus) ||

					(RSat::EAlphaIdNotSet == sendData.iAlphaId.iStatus) );

			}

		if (RSat::EIconQualifierNotSet != aIconQual)

			{

			ASSERT_EQUALS(aIconQual, sendData.iIconId.iQualifier);

			ASSERT_EQUALS(KIconOne, sendData.iIconId.iIdentifier);

			}

		else

			{

			ASSERT_EQUALS(RSat::ENoIconId, sendData.iIconId.iQualifier);

			}

		}

	AssertMockLtsyStatusL();

	}

/**

Handles sending a terminal response

@param aResp terminal response data

*/

void CCSatSendReceiveDataFU::GenerateSendDataTerminalResponseL(

		const RSat::TSendDataRspV2& aResp)

	{

	GenerateSendDataTerminalResponseL(aResp, KBipSendDataImmediately);

	}

/**

Handles sending a terminal response

@param aResp terminal response data

@param aCmdQual Command qualifier

@param aExpResult Expected result of TerminalRsp() request

*/

void CCSatSendReceiveDataFU::GenerateSendDataTerminalResponseL(

		const RSat::TSendDataRspV2& aResp,

		TUint8 aCmdQual,

		TInt aExpResult)

	{

	TTlv additionalInfoTlv;

	TPtrC8 additionalInfoTlvData(KNullDesC8);

	TPtrC genResultAddInfo(KNullDesC);

	if ( RSat::KMeProblem == aResp.iInfoType )

		{

		// prepare additional info for general result for expected data in mockLtsy

		genResultAddInfo.Set( aResp.iAdditionalInfo );

		}

	else if ( CommandPerformedSuccessfully(aResp.iGeneralResult) )

		{

		// prepare additional info Tlv data for expected data in mockLtsy

		additionalInfoTlv.AddTag(KTlvChannelDataLengthTag);

		additionalInfoTlv.AddByte(aResp.iChannelDataLength);//ETLV_ChannelDataLength

		additionalInfoTlvData.Set( additionalInfoTlv.GetDataWithoutTopLevelTag() );

		}

	RSat::RSat::TSendDataRspV2Pckg respPckg(aResp);

	GenerateTerminalResponseL(

			aResp.PCmdNumber(),

			KSendData,

			aCmdQual,

			RSat::ESendData,

			respPckg,

			genResultAddInfo,

			aResp.iGeneralResult,

			additionalInfoTlvData,

			aExpResult);

	AssertMockLtsyStatusL();

	}

/**

Prepares ReceiveData proactive command complete data for MockLtsy

@param aChannelDataLength Channel data length

@param aDelay Delay value for MockLtsy completion

*/

void CCSatSendReceiveDataFU::PrepareReceiveDataCompleteDataL(

		const TUint8* aChannelDataLength,

		TInt aDelay)

	{

	PrepareReceiveDataCompleteDataL(

			KPCmdNumberOne, aChannelDataLength, NULL, RSat::EIconQualifierNotSet,

			KErrNone, aDelay, RSat::KChannel1);

	}

/**

Prepares ReceiveData proactive command complete data for MockLtsy

@param aPCmdNumber Proactive command number.

@param aChannelDataLength Channel data length

@param aAlphaId Alpha identifier

@param aIconQual Type of icon

@param aResult Proactive command notify result

@param aDelay Delay value for MockLtsy completion

@param aDestDeviceId Command destination device Id

*/

void CCSatSendReceiveDataFU::PrepareReceiveDataCompleteDataL(

		TUint8 aPCmdNumber,

		const TUint8* aChannelDataLength,

		const TDesC8* aAlphaId,

		RSat::TIconQualifier aIconQual,

		TInt aResult,

		TInt aDelay,

		TUint8 aDestDeviceId)

	{

	TTlv tlv;

	ProactiveCmdTlvBegin(tlv, aPCmdNumber, KReceiveData, KReceiveDataQualifier, aDestDeviceId);

	if ( aChannelDataLength )

		{			

		tlv.AddTag(KTlvChannelDataLengthTag);

		tlv.AddByte(*aChannelDataLength);//ETLV_ChannelDataLength

		}

	if ( aAlphaId )

		{			

		tlv.AddTag(KTlvAlphaIdentifierTag);

		tlv.AddData(*aAlphaId);//ETLV_AlphaIdentifier

		}

	if ( ( RSat::ESelfExplanatory == aIconQual ) ||

			( RSat::ENotSelfExplanatory == aIconQual ) )

		{

		tlv.AddTag(KTlvIconIdentifierTag);

		tlv.AddByte((RSat::ESelfExplanatory == aIconQual)?0:1);//ETLV_IconQualifier

		tlv.AddByte(KIconOne);//ETLV_IconIdentifier

		}

	PrepareMockWithCompleteDataForPCmdNotifyL(tlv.End(), aResult, aDelay);

	}

/**

Tests for completion of RSat::NotifyReceiveDataPCmd request with specified

 channel data length and RSat::KChannel1 as the destination device to process

 the command

@param aChannelDataLength Channel data length

@param aResult Proactive command notify result

*/

void CCSatSendReceiveDataFU::TestNotifyReceiveDataPCmdL(

		const TUint8* aChannelDataLength,

		TInt aResult)

	{

	TestNotifyReceiveDataPCmdL(

			KPCmdNumberOne, aChannelDataLength, NULL, RSat::EIconQualifierNotSet,

			aResult, NULL, RSat::KChannel1);

	}