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

*/

#include <cstktsy/bertlv_defs.h>

#include <etel.h>

#include <etelmm.h>

#include <etelsat.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/mmtsy_names.h>

#include <satcs.h>

#include <ctsy/ltsy/mltsydispatchsatinterface.h>

#include <test/tmockltsydata.h>

#include <cstktsy/ttlv.h>

#include "ccsatgetinputfu.h"

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatGetInputFU, TestNotifyGetInputPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatGetInputFU, TestNotifyGetInputPCmd0001bL);

	ADD_TEST_STEP_ISO_CPP(CCSatGetInputFU, TestNotifyGetInputPCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatGetInputFU, TestNotifyGetInputPCmd0004L);

	END_SUITE;

	}

/**

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

@param aTlv Tlv to fill in

@param aPCmdNumber proactive command number

@param aCommandQualifier GetInput proactive command qualifier

*/

void GetInputProactiveCmdTlvBegin( 

		TTlv& aTlv, 

		TUint8 aPCmdNumber,

		TUint8 aCommandQualifier)

	{

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

	}

/**

Prepares a default GetInput data from the data to compare with lately in binary mode,

so that the data coincides in the fields whos default values is not specified by standards

(e.g. the rest of buffers)

@param aDefGetInpData GetInput structure to fill in the default data

@param aGetInpData GetInput structure containing the default values that is not specified by standards

*/

void PrepareDefaultGetInpData(RSat::TGetInputV1& aDefGetInpData, const RSat::TGetInputV1& aGetInpData)

	{

	Mem::Copy(&aDefGetInpData, &aGetInpData, sizeof(RSat::TGetInputV1));

	aDefGetInpData.iText.Zero();

	aDefGetInpData.iInputDisplayOption = RSat::EDisplayUserInput;

	aDefGetInpData.iRspFormat = RSat::EDigitOnlyUnpacked;

	aDefGetInpData.iRspLength.iMinRspLength = 0;

	aDefGetInpData.iRspLength.iMaxRspLength = 0;

	aDefGetInpData.iDefaultText.Zero();

	aDefGetInpData.iIconId.iQualifier = RSat::ENoIconId;

	aDefGetInpData.iHelp = RSat::ENoHelpAvailable;

	}

/**

Test support in SATTSY for successful RSat::NotifyGetInputPCmd request without terminal response generation

@param aPCmdNumber proactive command number

@param aGetInputQualifier GetInput proactive command qualifier

@param aGetInputText text for the Terminal to display in conjunction with asking the user to respond

@param aMinRspLength minimum length of the user response

@param aMaxRspLength maximum length of the user response

*/

void CCSatGetInputFU::TestGetInputSuccessfulWithoutTerminalResponseL(

		TUint8 aPCmdNumber,

		TUint8 aGetInputQualifier,

		const TDesC8& aGetInputText,

		TUint8 aMinRspLength,

		TUint8 aMaxRspLength)

	{

	PrepareMockWithExpDataForPCmdNotifyL(KGetInput);

	RSat::TGetInputV1 getInpData;

	RSat::TGetInputV1Pckg getInpDataPckg(getInpData);

	TRequestStatus requestStatus;

	iSat.NotifyGetInputPCmd(requestStatus, getInpDataPckg);

	TTlv getInpTlv;

	GetInputProactiveCmdTlvBegin( getInpTlv, aPCmdNumber, aGetInputQualifier );

	getInpTlv.AddTag(KTlvTextStringTag);

	getInpTlv.AddByte(K8BitDCS); //ETLV_DataCodingScheme

	getInpTlv.AddData(aGetInputText);

	getInpTlv.AddTag(KTlvResponseLengthTag);

	getInpTlv.AddByte(aMinRspLength); //ETLV_MinimumLengthOfResponse

	getInpTlv.AddByte(aMaxRspLength); //ETLV_MaximumLengthOfResponse

	PrepareMockWithCompleteDataForPCmdNotifyL(getInpTlv.End(), KErrNone);

	User::WaitForRequest(requestStatus);

	// check result

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	RSat::TGetInputV1 expGetInpData;

	RSat::TGetInputV1Pckg expGetInpDataPckg(expGetInpData);

	PrepareDefaultGetInpData(expGetInpData, getInpData);

	expGetInpData.iText.Copy(aGetInputText);

	expGetInpData.iRspLength.iMinRspLength = aMinRspLength;

	expGetInpData.iRspLength.iMaxRspLength = aMaxRspLength;

	if ( KUserInputMask & aGetInputQualifier )

		{

		// User input hidden

		expGetInpData.iInputDisplayOption = RSat::EHideUserInput;

		}

	else

		{

		// User input shown

		expGetInpData.iInputDisplayOption = RSat::EDisplayUserInput;

		}

	// Character set selected

	if ( KUCS2AlphabetMask & aGetInputQualifier )

		{

		// UCS2 alphabet selected

		expGetInpData.iRspFormat = RSat::EUcs2Alphabet;

		}

	else if ( KAlphabetMask & aGetInputQualifier )

		{

		if ( KGetInputSmsPackedMask & aGetInputQualifier )

			{

			// SMS default alphabet

			expGetInpData.iRspFormat = RSat::ESmsDefaultAlphabetPacked;

			}

		else

			{

			expGetInpData.iRspFormat = RSat::ESmsDefaultAlphabetUnpacked;

			}

		}

	else

		{

		if  ( KGetInputSmsPackedMask & aGetInputQualifier )

			{

			// Digit only

			expGetInpData.iRspFormat = RSat::EDigitOnlyPacked;

			}

		else

			{

			expGetInpData.iRspFormat = RSat::EDigitOnlyUnpacked;

			}

		}

	// Help information.

	if ( KHelpAvailabilityMask & aGetInputQualifier )

		{

		// Help information available

		expGetInpData.iHelp = RSat::EHelpAvailable;

		}

	else

		{

		// No help

		expGetInpData.iHelp = RSat::ENoHelpAvailable;

		}

	ASSERT_EQUALS(0, expGetInpDataPckg.Compare(getInpDataPckg));

	}

/**

Test support in SATTSY for successful RSat::NotifyGetInputPCmd request with terminal response about unsuccessful command processing

@param aPCmdNumber proactive command number

@param aError error code of the proactive command processing

@param aMeProblemAddInfo additional information in case of Me problem

@param aExpResult expected result of TerminalRsp() execution

*/

void CCSatGetInputFU::TestGetInputWithUnsuccessfulTerminalResponseL(

		TUint8 aPCmdNumber,

		RSat::TPCmdResult aError,

		const TDesC& aMeProblemAddInfo,

		const TInt aExpResult)

	{

	const TUint8 KGetInputQualifier = KAlphabetMask;	// SMS default alphabet, input in unpacked format, 

														// Terminal to echo text, no help information available

	_LIT8(KGetInputText, "<GET-INPUT-TEXT>"); 

	TestGetInputSuccessfulWithoutTerminalResponseL(aPCmdNumber, KGetInputQualifier, KGetInputText, 2, 30);

	//generate the terminal response

	RSat::TGetInputRspV1 resp;

	RSat::TGetInputRspV1Pckg respPckg(resp);

	resp.iGeneralResult = aError;

	resp.iAdditionalInfo.Zero();

	if ( RSat::KMeUnableToProcessCmd == aError )

		{

		resp.iInfoType = RSat::KMeProblem;

		resp.iAdditionalInfo.Append(aMeProblemAddInfo);

		}

	else

		{

		resp.iInfoType = RSat::KNoAdditionalInfo;

		}

	resp.iRspFormat = RSat::ESmsDefaultAlphabetUnpacked;

	resp.SetPCmdNumber(aPCmdNumber);

	GenerateTerminalResponseL(KGetInputQualifier, resp, K8BitDCS, aExpResult);

	AssertMockLtsyStatusL();

	}

/**

Handles sending a terminal response

@param aCommandQualifier get input proactive command qualifier

@param aResp terminal response data

@param aCodingScheme coding scheme of input data

@param aExpResult expected result of TerminalRsp() execution

*/

void CCSatGetInputFU::GenerateTerminalResponseL(

		TUint8 aCommandQualifier,

		const RSat::TGetInputRspV1& aResp,

		TUint8 aCodingScheme,

		const TInt aExpResult)

	{

	TPtrC genResultAddInfo(KNullDesC);

	TPtrC8 additionalInfoTlv(KNullDesC8);

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

		{

		TTlv textStringTlv;

		textStringTlv.AddTag(KTlvTextStringTag);

		textStringTlv.AddByte(aCodingScheme); //ETLV_DataCodingScheme

		TBuf8<RSat::KAdditionalInfoMaxSize> addInfo;

		addInfo.Zero();

		switch (aCodingScheme)

			{

			case KUCS2DCS:

				TSatUtility::Copy16to8LE(aResp.iAdditionalInfo, addInfo);

				break;

			case K7BitDefaultSmsDCS:

				TSatUtility::UCSToPacked7(aResp.iAdditionalInfo, addInfo);

				break;

			case K8BitDCS:

			default:

				addInfo.Copy(aResp.iAdditionalInfo);

				break;

			}

		textStringTlv.AddData(addInfo);

		additionalInfoTlv.Set( textStringTlv.GetDataWithoutTopLevelTag() );

		}

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

		{

		genResultAddInfo.Set( aResp.iAdditionalInfo );

		}

	RSat::TGetInputRspV1Pckg respPckg(aResp);

	CCSatComponentTestBase::GenerateTerminalResponseL(

			aResp.PCmdNumber(),

			KGetInput,

			aCommandQualifier,

			RSat::EGetInput,

			respPckg,

			genResultAddInfo,

			aResp.iGeneralResult,

			additionalInfoTlv,

			aExpResult);

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CSAT-GUI-TNGIPC-0001

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for RSat::NotifyGetInputPCmd

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifyGetInputPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatGetInputFU::TestNotifyGetInputPCmd0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

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

	// TEST C: Successful completion request of

	// RSat::NotifyGetInputPCmd when result is not cached.

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

	//

	// (GET INPUT, digits only, SMS default alphabet, Terminal to echo text, Terminal supporting 8 bit data Message)

	//

	PrepareMockWithExpDataForPCmdNotifyL(KGetInput);

	RSat::TGetInputV1 getInpData;

	RSat::TGetInputV1Pckg getInpDataPckg(getInpData);

	TRequestStatus requestStatus;

	iSat.NotifyGetInputPCmd(requestStatus, getInpDataPckg);

	TUint8 pcmdNumber = 1;

	TTlv getInpTlv;

	TUint8 getInputQualifier = 0; // digits (0-9, *, # and +) only, SMS default alphabet, input in unpacked format, Terminal to echo text, no help information available

	GetInputProactiveCmdTlvBegin( getInpTlv, pcmdNumber, getInputQualifier );

	getInpTlv.AddTag(KTlvTextStringTag);

	getInpTlv.AddByte(K8BitDCS); //ETLV_DataCodingScheme

	_LIT8(KGetInputText, "Enter 12345");

	getInpTlv.AddData(KGetInputText);

	getInpTlv.AddTag(KTlvResponseLengthTag);

	getInpTlv.AddByte(5); //ETLV_MinimumLengthOfResponse

	getInpTlv.AddByte(5); //ETLV_MaximumLengthOfResponse

	PrepareMockWithCompleteDataForPCmdNotifyL(getInpTlv.End(), KErrNone);

	User::WaitForRequest(requestStatus);

	// check results

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	ASSERT_EQUALS(0, Compare16bitDesWith8bitDesL(KGetInputText, getInpData.iText));

	ASSERT_EQUALS(RSat::EDisplayUserInput, getInpData.iInputDisplayOption);

	ASSERT_EQUALS(RSat::EDigitOnlyUnpacked, getInpData.iRspFormat);

	ASSERT_EQUALS(static_cast<TUint8>(5), getInpData.iRspLength.iMinRspLength);

	ASSERT_EQUALS(static_cast<TUint8>(5), getInpData.iRspLength.iMaxRspLength);

	ASSERT_EQUALS(0, KNullDesC().Compare(getInpData.iDefaultText));

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

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

	// check result by package

	RSat::TGetInputV1 expGetInpData;

	RSat::TGetInputV1Pckg expGetInpDataPckg(expGetInpData);

	PrepareDefaultGetInpData(expGetInpData, getInpData);

	expGetInpData.iText.Copy(KGetInputText);

	expGetInpData.iRspLength.iMinRspLength = 5;

	expGetInpData.iRspLength.iMaxRspLength = 5;

	ASSERT_EQUALS(0, expGetInpDataPckg.Compare(getInpDataPckg));

	//generate the terminal response

	RSat::TGetInputRspV1 resp;

	RSat::TGetInputRspV1Pckg respPckg(resp);

	resp.iGeneralResult = RSat::KSuccess;

	resp.iInfoType = RSat::KTextString;

	_LIT8(KUserInputText, "12345"); 

	resp.iAdditionalInfo.Copy(KUserInputText);

	resp.iRspFormat = RSat::EDigitOnlyUnpacked;

	resp.SetPCmdNumber(pcmdNumber);

	GenerateTerminalResponseL(getInputQualifier, resp);

	AssertMockLtsyStatusL();

	//

	// (GET INPUT, digits only, SMS default alphabet, packed, Hide user input)

	//

	PrepareMockWithExpDataForPCmdNotifyL(KGetInput);

	iSat.NotifyGetInputPCmd(requestStatus, getInpDataPckg);

	getInputQualifier = KUserInputMask|KHelpAvailabilityMask|KGetInputSmsPackedMask; // digits (0-9, *, # and +) only, SMS default alphabet, input in packed format, Hide user input, help information available

	GetInputProactiveCmdTlvBegin( getInpTlv, pcmdNumber, getInputQualifier );

	getInpTlv.AddTag(KTlvTextStringTag);

	getInpTlv.AddByte(K8BitDCS); //ETLV_DataCodingScheme

	_LIT8(KGetInputText2, "Enter a digit"); 

	getInpTlv.AddData(KGetInputText2);

	getInpTlv.AddTag(KTlvResponseLengthTag);

	getInpTlv.AddByte(1); //ETLV_MinimumLengthOfResponse

	getInpTlv.AddByte(1); //ETLV_MaximumLengthOfResponse

	getInpTlv.AddTag(KTlvDefaultTextTag);

	getInpTlv.AddByte(K8BitDCS); //ETLV_DataCodingScheme

	_LIT8(KDefaultText, "1"); 

	getInpTlv.AddData(KDefaultText);

	PrepareMockWithCompleteDataForPCmdNotifyL(getInpTlv.End(), KErrNone);

	User::WaitForRequest(requestStatus);

	// check results

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	PrepareDefaultGetInpData(expGetInpData, getInpData);

	expGetInpData.iText.Copy(KGetInputText2);

	expGetInpData.iRspLength.iMinRspLength = 1;

	expGetInpData.iRspLength.iMaxRspLength = 1;

	expGetInpData.iDefaultText.Copy(KDefaultText);

	expGetInpData.iHelp = RSat::EHelpAvailable;

	expGetInpData.iInputDisplayOption = RSat::EHideUserInput;

	expGetInpData.iRspFormat = RSat::EDigitOnlyPacked;

	ASSERT_EQUALS(0, expGetInpDataPckg.Compare(getInpDataPckg));

	//generate the terminal response

	resp.iGeneralResult = RSat::KSuccess;

	resp.iInfoType = RSat::KTextString;

	_LIT(KUserInputText2, "2"); 

	resp.iAdditionalInfo.Copy(KUserInputText2);

	resp.iRspFormat = RSat::EDigitOnlyPacked;

	resp.SetPCmdNumber(pcmdNumber);

	GenerateTerminalResponseL(getInputQualifier, resp, K7BitDefaultSmsDCS);

	AssertMockLtsyStatusL();

	//

	// (GET INPUT, SMS default alphabet, Terminal to echo text, Terminal supporting 8 bit data Message)

	//

	getInputQualifier = KAlphabetMask; // SMS default alphabet, input in unpacked format, Terminal to echo text, no help information available

	_LIT8(KGetInputText3, "Enter your account name"); 

	TestGetInputSuccessfulWithoutTerminalResponseL(pcmdNumber, getInputQualifier, KGetInputText3, 2, 30);

	//generate the terminal response

	resp.iGeneralResult = RSat::KSuccess;

	resp.iInfoType = RSat::KTextString;

	_LIT8(KUserInputText3, "Roman"); 

	resp.iAdditionalInfo.Copy(KUserInputText3);

	resp.iRspFormat = RSat::ESmsDefaultAlphabetUnpacked;

	resp.SetPCmdNumber(pcmdNumber);

	TTlv getInpRspTlv3;

	getInpRspTlv3.AddTag(KTlvTextStringTag);

	getInpRspTlv3.AddByte(K8BitDCS); //ETLV_DataCodingScheme

	getInpRspTlv3.AddData(KUserInputText3);

	GenerateTerminalResponseL(getInputQualifier, resp);

	AssertMockLtsyStatusL();

	//

	// (GET INPUT, SMS default alphabet, packed, Terminal to echo text)

	//

	getInputQualifier = KAlphabetMask|KGetInputSmsPackedMask; // SMS default alphabet, input in packed format, Terminal to echo text, no help information available

	TestGetInputSuccessfulWithoutTerminalResponseL(pcmdNumber, getInputQualifier, KGetInputText3, 2, 30);

	//generate the terminal response

	resp.iGeneralResult = RSat::KSuccess;

	resp.iInfoType = RSat::KTextString;

	_LIT(KUserInputText4, "Vladimir"); 

	resp.iAdditionalInfo.Copy(KUserInputText4);

	resp.iRspFormat = RSat::ESmsDefaultAlphabetPacked;

	resp.SetPCmdNumber(pcmdNumber);

	GenerateTerminalResponseL(getInputQualifier, resp, K7BitDefaultSmsDCS);

	AssertMockLtsyStatusL();

	//

	// (GET INPUT, UCS2 alphabet, Terminal to echo text)

	//

	getInputQualifier = KUCS2AlphabetMask; // UCS2 alphabet, Terminal to echo text, no help information available

	TestGetInputSuccessfulWithoutTerminalResponseL(pcmdNumber, getInputQualifier, KGetInputText3, 2, 30);

	//generate the terminal response

	resp.iGeneralResult = RSat::KSuccess;

	resp.iInfoType = RSat::KTextString;

	resp.iAdditionalInfo.Copy(KUserInputText4);

	resp.iRspFormat = RSat::EUcs2Alphabet;

	resp.SetPCmdNumber(pcmdNumber);

	GenerateTerminalResponseL(getInputQualifier, resp, KUCS2DCS);

	AssertMockLtsyStatusL();

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

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

	// from LTSY.

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

	getInputQualifier = 0; // digits (0-9, *, # and +) only, SMS default alphabet, input in unpacked format, Terminal to echo text, no help information available

	GetInputProactiveCmdTlvBegin( getInpTlv, pcmdNumber, getInputQualifier );

	getInpTlv.AddTag(KTlvTextStringTag);

	getInpTlv.AddByte(K8BitDCS); //ETLV_DataCodingScheme

	getInpTlv.AddData(KGetInputText);

	getInpTlv.AddTag(KTlvResponseLengthTag);

	getInpTlv.AddByte(5); //ETLV_MinimumLengthOfResponse

	getInpTlv.AddByte(5); //ETLV_MaximumLengthOfResponse

	PrepareMockWithCompleteDataForPCmdNotifyL(getInpTlv.End(), KErrNone);

	resp.iAdditionalInfo.Zero();

	resp.iAdditionalInfo.Append(RSat::KNoSpecificMeProblem);

	PrepareTerminalResponseMockDataL(pcmdNumber, KGetInput, getInputQualifier, resp.iAdditionalInfo, RSat::KMeUnableToProcessCmd, KNullDesC8);

	WaitForMockLTSYTerminated();

	AssertMockLtsyStatusL();

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

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