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

*/

#include "ccsatsendussdfu.h"

#include <etel.h>

#include <etelmm.h>

#include <test/tmockltsydata.h>

#include <cstktsy/ttlv.h>

#include <satcs.h>                  // Etel SAT IPC definitions

#include <ctsy/ltsy/mltsydispatchsatinterface.h>

#include <test/mockltsyindicatorids.h>

// It means that text is uncompressed and bits 1 to 0 are reserved and have no message class meaning 

//Reference: 3gpp ts 23.038

static const TUint8 KDataCodingGroup4 = 0x40; 

static const TUint8 KPcmdNumber = 1;

_LIT8(KAlphaId8,"7-bit USSD");

_LIT16(KAlphaId16,"7-bit USSD");

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

	{	

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0002L);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0004L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001bL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001cL);

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001dL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001eL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001fL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001gL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001hL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001iL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001jL);	

	ADD_TEST_STEP_ISO_CPP(CCSatSendUSSDFU, TestNotifySendUssdPCmd0001kL);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CSAT-SUSSD-SNSUPC-0001

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for RSat::NotifySendUssdPCmd

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySendUssdPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendUSSDFU::TestNotifySendUssdPCmd0001L()

	{	

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus requestStatus;	

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

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

	// from LTSY. (put this test first just for coverage)

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

	// Prepare TLV buffer for CompleteL	

	TTlv localInfoTlv;		

	// prepare 7-bit string	

	PrepareTlvWith7BitStr( localInfoTlv, KAlphaId8);

	const TDesC8& tlv = localInfoTlv.End();

	// Prepare TLV buffer for CompleteL	

	iMockLTSY.NotifyTerminated(requestStatus);

	// post Complete with KErrNone

	CompleteMockDispatchSatPcmdL(tlv, KErrNone);  

	// as TerminalResponse is called from CTSY

	// Prepare here ExpectL for it

	const TUint8 KNoCause = 0;

	PrepareTerminalResponseMockDataWithExpL(KPcmdNumber,	

			0,KNullDesC8, RSat::KMeUnableToProcessCmd,	KNoCause);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

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

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

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

	//Prepare data for ExpectL needed by NotifySendUssdPCmd

	//and post that ExpectL

	PrepareMockLDataWithExpL(KSendUssd);

	// Post Notify itself

	RSat::TSendUssdV1 ussd;

	RSat::TSendUssdV1Pckg ussdPck(ussd);

	iSat.NotifySendUssdPCmd(requestStatus, ussdPck);

	// post Complete with KErrNone

	CompleteMockDispatchSatPcmdL(tlv, KErrUnknown);		    

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrUnknown , requestStatus.Int());

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

	// TEST C: Successful completion request of

	// RSat::NotifySendUssdPCmd 

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

	// see test TestNotifySendUssdPCmd0001bL - TestNotifySendUssdPCmd0001iL

	AssertMockLtsyStatusL();

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

	}

/**

@SYMTestCaseID BA-CSAT-SUSSD-SNSUPC-0002

@SYMPREQ 1780

@SYMComponent  telephony_csat

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

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RSat::NotifySendUssdPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendUSSDFU::TestNotifySendUssdPCmd0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();	

	OpenSatL();

	TRequestStatus requestStatus;	

	//Prepare data for ExpectL needed by NotifySendUssdPCmd

	//and post that ExpectL

	PrepareMockLDataWithExpL(KSendUssd);

	// Post Notify itself

	RSat::TSendUssdV1 ussd;

	RSat::TSendUssdV1Pckg ussdPck(ussd);

	iSat.NotifySendUssdPCmd(requestStatus, ussdPck);

	iSat.CancelAsyncRequest(ESatNotifySendUssdPCmd);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrCancel, requestStatus.Int());		

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(1); // this

	}

/**

@SYMTestCaseID BA-CSAT-SUSSD-SNSUPC-0004

@SYMPREQ 1780

@SYMComponent  telephony_csat

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

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RSat::NotifySendUssdPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendUSSDFU::TestNotifySendUssdPCmd0004L()

	{	

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	RBuf8 data;

	CleanupClosePushL(data);

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

	User::LeaveIfError(sat2.Open(phone2));

	CleanupClosePushL(sat2);

	TRequestStatus requestStatus;

	TRequestStatus requestStatus2;

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

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

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

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

	// Post First Notify 

	PrepareMockLDataWithExpL(KSendUssd);

	RSat::TSendUssdV1 ussd;

	RSat::TSendUssdV1Pckg ussdPck(ussd);

	iSat.NotifySendUssdPCmd(requestStatus, ussdPck);

	// Post Second Notify	

	RSat::TSendUssdV1 ussd2;

	RSat::TSendUssdV1Pckg ussdPck2(ussd2);

	sat2.NotifySendUssdPCmd(requestStatus2, ussdPck2);		

	// Prepare TLV buffer for CompleteL

	TTlv localInfoTlv;	

	_LIT(KUssdString,"ABCDEFGHIJKLMNOPQRSTUVWXYZ-abcdefghijklmnopqrstuvwxyz-1234567890");

	TPtrC strToCompare(KUssdString);

	// prepare 7-bit string	

	PrepareTlvWith7BitStr( localInfoTlv, KAlphaId8);

	// post Complete with KErrNone

	CompleteMockDispatchSatPcmdL(localInfoTlv.End(), KErrNone);		 		    

	// wait for the first Complete

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

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

	ASSERT_EQUALS(0, ussd.iAlphaId.iAlphaId.Compare(KAlphaId16));	// as we got iAlphaId in UNICODE

	ASSERT_EQUALS(static_cast<TUint8> (ESms7BitDcs), ussd.iUssdString.iDcs);	

	ASSERT_EQUALS(0, ussd.iUssdString.iUssdString.Compare(strToCompare));	

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

	ASSERT_EQUALS(static_cast<TUint8>(0), ussd.iIconId.iIdentifier);

	// wait for the second Complete

	User::WaitForRequest(requestStatus2);

	ASSERT_EQUALS(KErrNone, requestStatus2.Int());		

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

	ASSERT_EQUALS(0, ussd2.iAlphaId.iAlphaId.Compare(KAlphaId16));	// as we got iAlphaId in UNICODE

	ASSERT_EQUALS(static_cast<TUint8> (ESms7BitDcs), ussd2.iUssdString.iDcs);	

	ASSERT_EQUALS(0, ussd2.iUssdString.iUssdString.Compare(strToCompare));	

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

	ASSERT_EQUALS(static_cast<TUint8>(0), ussd2.iIconId.iIdentifier);

	_LIT(KTextString,"USSD string received from SS");

	// USSD string received from SS

	// in 7bit codding (taken from 3GPP TS 31.124 V7.4.0 (2008-06)) 

	static const TUint8 textStr[] = {0xD5, 0xE9, 0x94, 0x08, 0x9A, 0xD3, 0xE5, 0x69, 

						0xF7, 0x19, 0x24, 0x2F, 0x8F, 0xCB, 0x69, 0x7B, 0x99,

						0x0C, 0x32, 0xCB, 0xDF, 0x6D, 0xD0, 0x74, 0x0A}; 	

	TBuf8<RSat::KStringMaxSize> text7bit;	

	text7bit.Append(textStr, sizeof (textStr));

	// Prepare and call TerminalResponse from the first Client

	PrepareTerminalResponseMockDataWithExpL(

			KPcmdNumber,		

			ESms7BitDcs, 	

			text7bit);		

 	// call TerminalRsp

	RSat::TSendUssdRspV1 resp;

	RSat::TSendUssdRspV1Pckg respPckg(resp);

	resp.iGeneralResult = RSat::KSuccess;	

	resp.iUssdString.iDcs = ESms7BitDcs;

	resp.iUssdString.iUssdString.Copy(KTextString);	

	resp.SetPCmdNumber(KPcmdNumber);	

	TerminalResponseL(respPckg);	

	// Prepare and call TerminalResponse from the second Client	

	// with some error data

	PrepareTerminalResponseMockDataWithExpL(

				KPcmdNumber,		

				ESms7BitDcs, 	

				KNullDesC8,

				RSat::KMeUnableToProcessCmd,

				0,

				EFalse);	

	resp.iGeneralResult = RSat::KMeUnableToProcessCmd; 	

	TerminalResponseL(respPckg);

	AssertMockLtsyStatusL();	

	CleanupStack::PopAndDestroy(5, this); // ..., data, this

	}

/**

@SYMTestCaseID BA-CSAT-SUSSD-SNSUPC-0001b

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Expected Sequence 1.1 (SEND USSD, 7-bit data, successful)

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySendUssdPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendUSSDFU::TestNotifySendUssdPCmd0001bL()

	{	

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus requestStatus;	

	//

	// Expected Sequence 1.1 (SEND USSD, 7-bit data, successful)

	// see  27.22.4.12 of  3GPP TS 31.124 V7.4.0 (2008-06) 

	//	

	//Prepare data for ExpectL needed by NotifySendUssdPCmd

	//and post that ExpectL

	PrepareMockLDataWithExpL(KSendUssd);

	// Post Notify itself

	RSat::TSendUssdV1 ussd;

	RSat::TSendUssdV1Pckg ussdPck(ussd);

	iSat.NotifySendUssdPCmd(requestStatus, ussdPck);

	// Prepare TLV buffer for CompleteL

	TTlv localInfoTlv;	

	_LIT(KUssdString,"ABCDEFGHIJKLMNOPQRSTUVWXYZ-abcdefghijklmnopqrstuvwxyz-1234567890");

	TPtrC strToCompare(KUssdString);

	// prepare 7-bit string	

	PrepareTlvWith7BitStr( localInfoTlv, KAlphaId8);

	// post Complete with KErrNone

	CompleteMockDispatchSatPcmdL(localInfoTlv.End(), KErrNone);		    

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

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

	ASSERT_EQUALS(0, ussd.iAlphaId.iAlphaId.Compare(KAlphaId16));	// as we got iAlphaId in UNICODE

	ASSERT_EQUALS(static_cast<TUint8> (ESms7BitDcs), ussd.iUssdString.iDcs);	

	ASSERT_EQUALS(0, ussd.iUssdString.iUssdString.Compare(strToCompare));	

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

	ASSERT_EQUALS(static_cast<TUint8>(0), ussd.iIconId.iIdentifier);

	// there is no sence in emulation of transmission between ME and USS here

	// so prepare and send Terminal response

	_LIT(KTextString,"USSD string received from SS");

	// USSD string received from SS

	// in 7bit codding (taken from 3GPP TS 31.124 V7.4.0 (2008-06)) 

	static const TUint8 textStr[] = {0xD5, 0xE9, 0x94, 0x08, 0x9A, 0xD3, 0xE5, 0x69, 

						0xF7, 0x19, 0x24, 0x2F, 0x8F, 0xCB, 0x69, 0x7B, 0x99,

						0x0C, 0x32, 0xCB, 0xDF, 0x6D, 0xD0, 0x74, 0x0A}; 	

	TBuf8<RSat::KStringMaxSize> text7bit;	

	text7bit.Append(textStr, sizeof (textStr));

	PrepareTerminalResponseMockDataWithExpL(

			KPcmdNumber,		

			ESms7BitDcs, 	

			text7bit);

 	// call TerminalRsp

	RSat::TSendUssdRspV1 resp;

	RSat::TSendUssdRspV1Pckg respPckg(resp);

	resp.iGeneralResult = RSat::KSuccess;	

	resp.iUssdString.iDcs = ESms7BitDcs;

	resp.iUssdString.iUssdString.Copy(KTextString);

	resp.SetPCmdNumber(KPcmdNumber);	

	TerminalResponseL(respPckg);

	AssertMockLtsyStatusL();

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

	}

/**

@SYMTestCaseID BA-CSAT-SUSSD-SNSUPC-0001c

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Expected Sequence 1.2 (SEND USSD, 8-bit data, successful)

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySendUssdPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendUSSDFU::TestNotifySendUssdPCmd0001cL()

	{	

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus requestStatus;	

	//

	// Expected Sequence 1.2 (SEND USSD, 8-bit data, successful)

	// see  27.22.4.12 of  3GPP TS 31.124 V7.4.0 (2008-06) 

	//	

	//Prepare data for ExpectL needed by NotifySendUssdPCmd

	//and post that ExpectL

	PrepareMockLDataWithExpL(KSendUssd);

	// Post Notify itself

	RSat::TSendUssdV1 ussd;

	RSat::TSendUssdV1Pckg ussdPck(ussd);

	iSat.NotifySendUssdPCmd(requestStatus, ussdPck);

	// Prepare TLV buffer for CompleteL

	TTlv localInfoTlv;	

	_LIT8(KAlphaId8bit8, "8-bit USSD");

	_LIT16(KAlphaId8bit16, "8-bit USSD");	

	_LIT8(KUssdString,"ABCDEFGHIJKLMNOPQRSTUVWXYZ-abcdefghijklmnopqrstuvwxyz-1234567890");		

	PrepareTlv(localInfoTlv, ESms8BitDcs|KDataCodingGroup4, KUssdString, KAlphaId8bit8);

	// post Complete with KErrNone

	CompleteMockDispatchSatPcmdL(localInfoTlv.End(), KErrNone);		    

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

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

	ASSERT_EQUALS(0, ussd.iAlphaId.iAlphaId.Compare(KAlphaId8bit16)); // as we got 	iAlphaId in UNICODE

	ASSERT_EQUALS(static_cast<TUint8> (ESms8BitDcs|KDataCodingGroup4), ussd.iUssdString.iDcs);	

	// prepare 16-bit string	

	TBuf16<RSat::KStringMaxSize> string16bit;	

	string16bit.Copy(KUssdString);	

	ASSERT_EQUALS(0, ussd.iUssdString.iUssdString.Compare(string16bit));	

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

	ASSERT_EQUALS(static_cast<TUint8>(0), ussd.iIconId.iIdentifier);

	// there is no sence in emulation of transmission  ME <-> USS and ME<->USER  here

	// so prepare and send Terminal response

	_LIT8(KTextString, "USSD string received from SS");

	PrepareTerminalResponseMockDataWithExpL(

			KPcmdNumber,				

			ESms8BitDcs, 	

			KTextString);

 	// call TerminalRsp

	RSat::TSendUssdRspV1 resp;

	RSat::TSendUssdRspV1Pckg respPckg(resp);

	resp.iGeneralResult = RSat::KSuccess;	

	resp.iUssdString.iDcs = ESms8BitDcs|KDataCodingGroup4;

	resp.iUssdString.iUssdString.Copy(KTextString);

	resp.SetPCmdNumber(KPcmdNumber);	

	TerminalResponseL(respPckg);

	AssertMockLtsyStatusL();

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

	}

/**

@SYMTestCaseID BA-CSAT-SUSSD-SNSUPC-0001d

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Expected Sequence 1.3 (SEND USSD, UCS2 data, successful)

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySendUssdPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendUSSDFU::TestNotifySendUssdPCmd0001dL()

	{	

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus requestStatus;	

	//

	// Expected Sequence 1.3 (SEND USSD, UCS2 data, successful)

	// see  27.22.4.12 of  3GPP TS 31.124 V7.4.0 (2008-06) 

	//	

	//Prepare data for ExpectL needed by NotifySendUssdPCmd

	//and post that ExpectL

	PrepareMockLDataWithExpL(KSendUssd);

	// Post Notify itself

	RSat::TSendUssdV1 ussd;

	RSat::TSendUssdV1Pckg ussdPck(ussd);

	iSat.NotifySendUssdPCmd(requestStatus, ussdPck);

	// Prepare TLV buffer for CompleteL

	TTlv localInfoTlv;

	// prepare UCS2 string	

	// "Hello" in Russian

	// (taken from 3GPP TS 31.124 V7.4.0 (2008-06)) 

	TUint8 str[] = {0x04, 0x17, 0x04, 0x14, 0x04, 0x20, 0x04, 0x10, 0x04, 0x12, 0x04,

					0x21, 0x04, 0x22, 0x04, 0x12, 0x04, 0x23, 0x04, 0x19, 0x04, 0x22,

					0x04, 0x15};

	TUint16 str16[] = {	0x0417, 0x0414, 0x0420, 0x0410, 0x0412, 0x0421,

						0x0422, 0x0412, 0x0423, 0x0419, 0x0422,	0x0415};	

	TBuf8<RSat::KStringMaxSize> stringUCS2;

	TBuf<RSat::KStringMaxSize> strToCompare;;

	stringUCS2.Append(str, sizeof (str));

	strToCompare.Append(str16, sizeof (str16)/2);

	PrepareTlv(localInfoTlv, ESms16BitDcs|KDataCodingGroup4, stringUCS2, KAlphaId8);