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

*/

#include "ccsatselectitemfu.h"

#include <etel.h>

#include <etelmm.h>

#include <satcs.h>

#include <test/tmockltsydata.h>

#include <cstktsy/tsatutility.h>

const TUint8 KPCmdNumber = 1;

const TUint8 KSelItmQualifierEmpty = 0x00;

_LIT8(KToolkitSelectAlphaId, "Toolkit Select"); 

const TUint8 KNumItemsThree = 3;

const TUint8 KNumItemsFour = 4;

const TUint8 KItemIds[KNumItemsFour] = {1,2,3,4};

_LIT8(KItemName1, "Item 1");

_LIT8(KItemName2, "Item 2");

_LIT8(KItemName3, "Item 3");

_LIT8(KItemName4, "Item 4");

const TPtrC8 KItemNames[KNumItemsFour] = 

	{

		KItemName1(),

		KItemName2(),

		KItemName3(),

		KItemName4()

	};

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001bL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001cL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001dL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001eL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001fL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001gL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001hL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001iL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001jL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001kL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0001lL);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatSelectItemFU, TestNotifySelectItemPCmd0004L);

	END_SUITE;

	}

/**

Resets RSat::SelectItemVx data fields

@param aSelItmData data to be reset

*/

LOCAL_C void ResetSelectItemData(RSat::TMenuItemBaseV1& aSelItmData)

	{

	// reset public members

	switch( aSelItmData.ExtensionId() )

		{

		case RSat::KSatV2:

			(static_cast<RSat::TSelectItemV2*>(&aSelItmData))->iPreference = 

					RSat::ESelectionPreferenceNotSet;

			// there is no need in break

			// do the following for both cases

		case RSat::KSatV1:

		default:

			{

			RSat::TSelectItemV1& selItmDataV1( *static_cast<RSat::TSelectItemV1*>(&aSelItmData) );

			selItmDataV1.iAlphaId.iStatus = RSat::EAlphaIdNotSet;

			selItmDataV1.iHelp = RSat::EHelpNotSet;

			selItmDataV1.iDefaultItemId = 0;

			selItmDataV1.iIconId.iQualifier = RSat::EIconQualifierNotSet;

			selItmDataV1.iIconListQualifier = RSat::EIconQualifierNotSet;

			selItmDataV1.iPresentationType = RSat::EPresentationTypeNotSet;

			selItmDataV1.iAlphaId.iAlphaId.SetLength(0);

			}

			break;

		}

	// reset protected members;

	aSelItmData.SetPCmdNumber(0);

	aSelItmData.Reset();

	}

/**

Fills in a Tlv with command details and device identities for DisplayText proactive command

@param aTlv Tlv to fill in

@param aPCmdNumber proactive command number

@param aCommandQualifier DisplayText proactive command qualifier

*/

LOCAL_C void SelectItemProactiveCmdTlvBegin( 

		TTlv& aTlv, 

		TUint8 aPCmdNumber,

		TUint8 aCommandQualifier)

	{

	ProactiveCmdTlvBegin( aTlv, aPCmdNumber, KSelectItem, aCommandQualifier, KMe );

	}

/**

Prepares Select Item proactive command complete data for Mock

@param aPCmdNumber Proactive command number

@param aCmdQual Command qualifier

@param aAlphaIdStatus Alpha identifier status

@param aAlphaId Alpha identifier

@param aNumItems Number of menu items

@param aItemIds Array of menu items identifier

@param aItemNames Array of menu items names

@param aActionArr Array of next actions

@param aIconQual Type of icon

@param aIcon Icon address

@param aIconListQual Type of icons for menu items

@param aIconList Array of icon addresses for menu items

@param aDefaultItem Default item id

@param aResult Proactive command notify result

@param aDelay Delay value for MockLtsy completion

*/

void CCSatSelectItemFU::PrepareSelItemCompleteDataL(

		TUint8 aPCmdNumber,

		TUint8 aCmdQual,

		RSat::TAlphaIdStatus aAlphaIdStatus,

		const TDesC8& aAlphaId,

		TUint8 aNumItems,

		const TUint8* aItemIds,

		const TPtrC8* aItemNames,

		const RArray<TUint32>* aActionArr,

		RSat::TIconQualifier aIconQual,

		TUint8 aIcon,

		RSat::TIconQualifier aIconListQual,

		const RArray<TUint32>* aIconList,

		TUint8 aDefaultItem,

		TInt aResult,

		TInt aDelay)

	{

	TTlv tlv;

	SelectItemProactiveCmdTlvBegin( tlv, aPCmdNumber, aCmdQual );

	if( (RSat::EAlphaIdProvided == aAlphaIdStatus) ||

			(RSat::EAlphaIdNull == aAlphaIdStatus))

		{			

		tlv.AddTag(KTlvAlphaIdentifierTag);

		tlv.AddData(aAlphaId);//ETLV_AlphaIdentifier

		}

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

		{

		tlv.AddTag(KTlvItemTag);

		tlv.AddByte(aItemIds[i]); //item identifier

		tlv.AddData(aItemNames[i]);

		}

	if(aActionArr)

		{

		tlv.AddTag(KTlvItemsNextActionIndicatorTag);

		TInt count = aActionArr->Count();

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

			{

			tlv.AddByte((*aActionArr)[i]); 

			}

		}

	if(RSat::EIconQualifierNotSet != aIconQual)

		{

		tlv.AddTag(KTlvIconIdentifierTag);

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

		tlv.AddByte(aIcon);

		}

	if(RSat::EIconQualifierNotSet != aIconListQual)

		{

		tlv.AddTag(KTlvItemIconIdentifierListTag);

		tlv.AddByte((RSat::ESelfExplanatory == aIconListQual)?0:1);

		if ( aIconList )

			{

			TInt iconCount = aIconList->Count();

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

				{

				tlv.AddByte((*aIconList)[i]);

				}

			}

		}

	if( 0 < aDefaultItem )

		{

		tlv.AddTag(KTlvItemIdentifierTag);

		tlv.AddByte(aDefaultItem); // ETLV_IdentifierOfItemChosen

		}

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

	}

/**

Prepares and calls Select Item proactive command

@param aPCmdNumber Proactive command number

@param aCmdQual Command qualifier

@param aParamVersion Parameter version

@param aAlphaIdStatus Alpha identifier status

@param aAlphaId Alpha identifier

@param aNumItems Number of menu items

@param aItemIds Array of menu items identifier

@param aItemNames Array of menu items names

@param aActionArr Array of next actions

@param aIconQual Type of icon

@param aIcon Icon address

@param aIconListQual Type of icons for menu items

@param aIconList Array of icon addresses for menu items

@param aDefaultItem Default item id

@param aResult Proactive command notify result

@param aAlphaIdCheck Alpha identifier value to ckeck with returned value

@param aItemNamesCheck Array of menu items names to ckeck with returned value

*/

void CCSatSelectItemFU::TestNotifySelectItemPCmdL(

		TUint8 aPCmdNumber,

		TUint8 aCmdQual,

		RSat::TSatVersion aParamVersion,

		RSat::TAlphaIdStatus aAlphaIdStatus,

		const TDesC8& aAlphaId,

		TUint8 aNumItems,

		const TUint8* const aItemIds,

		const TPtrC8* aItemNames,

		const RArray<TUint32>* aActionArr,

		RSat::TIconQualifier aIconQual,

		TUint8 aIcon,

		RSat::TIconQualifier aIconListQual,

		const RArray<TUint32>* aIconList,

		TUint8 aDefaultItem,

		TInt aResult,

		const TDesC16* aAlphaIdCheck,

		const TPtrC16* aItemNamesCheck)

	{

	PrepareMockWithExpDataForPCmdNotifyL(KSelectItem);

	PrepareSelItemCompleteDataL(

			aPCmdNumber, aCmdQual, aAlphaIdStatus, aAlphaId, aNumItems, aItemIds,

			aItemNames, aActionArr, aIconQual, aIcon, aIconListQual, aIconList,

			aDefaultItem, aResult);

	RSat::TMenuItemBaseV1* selItmData = NULL;

	TInt selItmDataSize(0);

	switch ( aParamVersion )

		{

		case RSat::KSatV1:

			{

			selItmData = new (ELeave) RSat::TSelectItemV1();

			selItmDataSize = sizeof(RSat::TSelectItemV1);

			}

			break;

		case RSat::KSatV2:

		default:

			{

			selItmData = new (ELeave) RSat::TSelectItemV2();

			selItmDataSize = sizeof(RSat::TSelectItemV2);

			aParamVersion = RSat::KSatV2;

			}

			break;

		}

	CleanupStack::PushL(selItmData);

	ResetSelectItemData(*selItmData);

	TRequestStatus requestStatus;

	TPtr8 selItmDataPckg(reinterpret_cast<TUint8*>(selItmData), selItmDataSize, selItmDataSize);

	iSat.NotifySelectItemPCmd(requestStatus, selItmDataPckg);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(aResult, requestStatus.Int());

	// check results

	const RSat::TSelectItemV1& selItmDataV1(

			*static_cast<RSat::TSelectItemV1*>(selItmData));

	if ( KErrNone == aResult )

		{

		ASSERT_EQUALS(aPCmdNumber, selItmDataV1.PCmdNumber());

		if ( RSat::KSatV1 != aParamVersion )

			{

			if ( KSelectItemSelectUsingSoftKeyMask == 

					(KSelectItemSelectUsingSoftKeyMask & aCmdQual) )

				{

				ASSERT_EQUALS( RSat::ESoftKeyPreferred,

						static_cast<RSat::TSelectItemV2*>(selItmData)->iPreference );

				}

			else

				{

				ASSERT_TRUE( RSat::ESoftKeyPreferred !=

						static_cast<RSat::TSelectItemV2*>(selItmData)->iPreference );

				}

			}

		if ( KHelpAvailabilityMask == (KHelpAvailabilityMask & aCmdQual) )

			{

			ASSERT_EQUALS(RSat::EHelpAvailable, selItmDataV1.iHelp);

			}

		else

			{

			ASSERT_EQUALS(RSat::ENoHelpAvailable, selItmDataV1.iHelp);

			}

		// Presentation as a choice of navigation options 

		if ( KSelectItemChoiceOfNavigation == 

				(KSelectItemPresentationTypeMask & aCmdQual) )

			{

			ASSERT_EQUALS(RSat::ENavigationOptions, selItmDataV1.iPresentationType);

			}

		// Presentation as a choice of data values 

		else if ( KSelectItemChoiceOfData == 

					(KSelectItemPresentationTypeMask & aCmdQual) )

			{

			ASSERT_EQUALS(RSat::EDataValues, selItmDataV1.iPresentationType);

			}

		else

			{

			ASSERT_TRUE( (RSat::ENotSpecified == selItmDataV1.iPresentationType) );

			}

		if(RSat::EIconQualifierNotSet != aIconQual)

			{

			ASSERT_EQUALS(aIconQual, selItmDataV1.iIconId.iQualifier);

			ASSERT_EQUALS(aIcon, selItmDataV1.iIconId.iIdentifier);

			}

		else

			{

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

			}

		if(RSat::EIconQualifierNotSet != aIconListQual)

			{

			ASSERT_EQUALS(aIconListQual, selItmDataV1.iIconListQualifier);

			}

		else

			{

			ASSERT_EQUALS(RSat::ENoIconId, selItmDataV1.iIconListQualifier);

			}

		ASSERT_EQUALS(static_cast<TUint8>(aDefaultItem), selItmDataV1.iDefaultItemId);

		if( RSat::EAlphaIdProvided == aAlphaIdStatus )

			{

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

			if ( aAlphaIdCheck )

				{

				ASSERT_EQUALS( 0, aAlphaIdCheck->Compare(selItmDataV1.iAlphaId.iAlphaId));

				}

			else

				{

				ASSERT_EQUALS(0, Compare16bitDesWith8bitDesL(aAlphaId, selItmDataV1.iAlphaId.iAlphaId));

				}

			}

		else if ( RSat::EAlphaIdNull == aAlphaIdStatus )

			{

			ASSERT_TRUE( RSat::EAlphaIdProvided != selItmDataV1.iAlphaId.iStatus );

			}

		else

			{

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

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

			}

		ASSERT_EQUALS(static_cast<TUint>(aNumItems), selItmDataV1.NumberOfItems());

		if(0 < aNumItems)

			{

			ASSERT_TRUE( !selItmDataV1.IsRemoveMenu() );

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

				{

				RSat::TItem item;

				TInt action;

				TInt iconId;

				ASSERT_EQUALS( KErrNone,

						selItmDataV1.GetItem( i + 1, item, action, iconId));

				ASSERT_EQUALS( aItemIds[i], item.iItemId );

				if ( aItemNamesCheck )

					{

					ASSERT_EQUALS( 0, aItemNamesCheck[i].Compare(item.iItemString) );

					}

				else

					{

					ASSERT_EQUALS(0, Compare16bitDesWith8bitDesL(aItemNames[i], item.iItemString));

					}

				if( aActionArr && (aNumItems == aActionArr->Count()) )

					{

					ASSERT_EQUALS(static_cast<TInt>((*aActionArr)[i]), action);

					}

				else

					{

					ASSERT_EQUALS(KErrNotFound, action);

					}

				if( (RSat::EIconQualifierNotSet != aIconListQual) && aIconList && ( aNumItems == aIconList->Count()) )

					{

					ASSERT_EQUALS(static_cast<TInt>((*aIconList)[i]), iconId);

					}

				else

					{

					ASSERT_EQUALS(KErrNotFound, iconId);

					}

				}

			}

		else

			{

			ASSERT_TRUE( selItmDataV1.IsRemoveMenu() );

			}

		}

	CleanupStack::PopAndDestroy(selItmData);

	AssertMockLtsyStatusL();

	}

/**

Handles sending a terminal response

@param aSelItmCmdQualifier select item proactive command qualifier

@param aResp terminal response data

@param aExpResult expected result of TerminalRsp() execution 

*/

void CCSatSelectItemFU::GenerateSelItemTerminalResponseL(

		TUint8 aSelectItemPCmdQualifier,

		const RSat::TSelectItemRspV1& aResp,

		const TInt aExpResult)

	{

	TPtrC genResultAddInfo(KNullDesC);

	TPtrC8 additionalInfoTlv(KNullDesC8);

	if ( (RSat::KItemIdentifier == aResp.iInfoType) && 

			( (RSat::KHelpRequestedByUser == aResp.iGeneralResult) ||

					(CommandPerformedSuccessfully(aResp.iGeneralResult)) ) )

		{

		TTlv itmChosenTlv;

		itmChosenTlv.AddTag(KTlvItemIdentifierTag);

		// ETLV_IdentifierOfItemChosen

		itmChosenTlv.AddByte( static_cast<TUint8>(aResp.iAdditionalInfo[0]) );

		additionalInfoTlv.Set( itmChosenTlv.GetDataWithoutTopLevelTag() );

		}

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

		{

		genResultAddInfo.Set( aResp.iAdditionalInfo );

		}

	RSat::TSelectItemRspV1Pckg respPckg(aResp);

	GenerateTerminalResponseL(

			aResp.PCmdNumber(),

			KSelectItem,

			aSelectItemPCmdQualifier,

			RSat::ESelectItem,

			respPckg,

			genResultAddInfo,

			aResp.iGeneralResult,

			additionalInfoTlv,

			aExpResult);

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CSAT-SI-SNSIPC-0001

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for RSat::NotifySelectItemPCmd

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySelectItemPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSelectItemFU::TestNotifySelectItemPCmd0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

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

	// TEST E: Unsolicited completion of RSat::NotifySelectItemPCmd

	// from LTSY.

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

	PrepareSelItemCompleteDataL(

			KPCmdNumber, KSelItmQualifierEmpty, RSat::EAlphaIdProvided, KToolkitSelectAlphaId,

			KNumItemsFour, KItemIds, KItemNames);

	RSat::TAdditionalInfo addInfo;

	addInfo.Append(RSat::KNoSpecificMeProblem);

	PrepareTerminalResponseMockDataL(

			KPCmdNumber, KSelectItem, KSelItmQualifierEmpty,

			addInfo, RSat::KMeUnableToProcessCmd);

	WaitForMockLTSYTerminated();

	AssertMockLtsyStatusL();

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

	// TEST F: Coverage test(s) for RSat::NotifySelectItemPCmd

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