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

*/

#include <etel.h>

#include <etelmm.h>

#include <satcs.h>

#include <ctsy/ltsy/sat_defs.h>

#include <test/tmockltsydata.h>

#include <test/mockltsyindicatorids.h>

#include <ctsy/ltsy/mltsydispatchsatinterface.h>

//#include "csatnotificationstsy.h"

#include "ccsatsendsmsfu.h"

const TUint8 KTestPCmdNumber = 1;

_LIT8(KDialingNumberString8,"112233445566778");

_LIT16(KDialingNumberString16,"112233445566778");

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatSendSMSFU, TestNotifySendSmPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendSMSFU, TestNotifySendSmPCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatSendSMSFU, TestNotifySendSmPCmd0004L);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CSAT-SSMS-SNSSMPC-0001

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for RSat::NotifySendSmPCmd

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySendSmPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendSMSFU::TestNotifySendSmPCmd0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

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

	// TEST C: Successful completion request of RSat::NotifySendSmPCmd 

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

	// Run some of test sequences listed in 3GPP TS 31.124 clause 27.22.4.10 "SEND SHORT MESSAGE"

	DoPositiveNotifySendSmPCmdTestL(ETestSequence14);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence15);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence16);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence17);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence18);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence31A);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence31B);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence32A);

	DoPositiveNotifySendSmPCmdTestL(ETestSequence32B);	

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

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

	// from LTSY.

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

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	// Create unsolicted "SEND SHORT MESSAGE"

	TTpdu tpdu;

	MockCompleteSendSmPCmdL(tpdu,ETestUnsolictedCompletion);

	// Prime Mock for forthcoming "TERMINAL RESPONSE" that is invoked internally by SAT TSY

	MockPrimeSendSmTerminalResponseL(ETestUnsolictedCompletion);

	User::WaitForRequest(mockLtsyStatus);

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	

	AssertMockLtsyStatusL();

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

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

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

	DoPositiveNotifySendSmPCmdTestL(ETestMissingAddressType);

	DoPositiveNotifySendSmPCmdTestL(ETestMissingDiallingNumber);

	DoPositiveNotifySendSmPCmdTestL(ETestSmsCommand);

	DoPositiveNotifySendSmPCmdTestL(ETestRelativeVPF);

	DoPositiveNotifySendSmPCmdTestL(ETestEnchancedVPF);	

	DoPositiveNotifySendSmPCmdTestL(ETestAbsoluteVPF);

	DoPositiveNotifySendSmPCmdTestL(ETestRelativeVPFPacked);

	DoPositiveNotifySendSmPCmdTestL(ETestEnchancedVPFPacked); 

	DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsCommand);	

	DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit8bit);

	DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit7bit);

	DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit8bitPacked);	

	DoNegativeNotifySendSmPCmdTestL(ETestTooBigSmsSubmit7bitPacked);

	DoNegativeNotifySendSmPCmdTestL(ETestMissingSmsTpdu);	

	DoTestTerminalResponseL();

	DoPositiveNotifySendSmPCmdTestL(ETestAbsoluteVPFPacked);  

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

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

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

	tpdu.Zero();

	MockPrimeSendSmPCmdL(tpdu,ETestSequence11,KErrUnknown);

	TRequestStatus reqStatus;

	RSat::TSendSmV1 sendSm;

	RSat::TSendSmV1Pckg sendSmPckg(sendSm);

	iSat.NotifySendSmPCmd(reqStatus,sendSmPckg);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrUnknown, reqStatus.Int());	

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(this);

	}

/**

@SYMTestCaseID BA-CSAT-SSMS-SNSSMPC-0002

@SYMPREQ 1780

@SYMComponent  telephony_csat

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

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RSat::NotifySendSmPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendSMSFU::TestNotifySendSmPCmd0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	OpenSatL();

	// tell Mock about forthcoming RSat::NotifySendSmPCmd

	const TUint8 KPcmdCode = KSendShortMessage;

	const TPckgC<TUint8> KPcmdCodePckg(KPcmdCode);

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

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

	// Test cancelling of RSat::NotifySendSmPCmd

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

	TRequestStatus reqStatus;

	RSat::TSendSmV1 sendSm;

	RSat::TSendSmV1Pckg sendSmPckg(sendSm);

	iSat.NotifySendSmPCmd(reqStatus,sendSmPckg);

	iSat.CancelAsyncRequest(ESatNotifySendSmPCmd);

	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(this);

	}

/**

@SYMTestCaseID BA-CSAT-SSMS-SNSSMPC-0004

@SYMPREQ 1780

@SYMComponent  telephony_csat

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

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RSat::NotifySendSmPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatSendSMSFU::TestNotifySendSmPCmd0004L()

	{

	// Note: Most likely this test should be fixed.

	// Currently *all simultenious* RSat::NotifyXXXXPCmd() requests complete

	// with KErrNone when corresponding proactive command arrives succesfully.

	// That's the problem because once a RSat client gets a proactive command

	// it should reply with appropriate "TERMINAL RESPONSE" after processing it.

	// So if there are *two or more* independant clients listening for the same 

	// proactive command then *two or more* "TERMINAL RESPONSE"s for that command

	// are likely. Such behaviour seems to be erroneous because once a SIM application 

	// has issued a proactive command it would expect a *single* "TERMINAL RESPONSE" 

	// in reply but not two or more.

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

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

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

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

	// Prime Mock with "SEND SHORT MESSAGE" proactive command

	TTpdu tpdu;

	MockPrimeSendSmPCmdL(tpdu, ETestSequence11);

	// Invoke 1-st client RSat::NotifySendSmPCmd()

	TRequestStatus reqStatus1;

	RSat::TSendSmV1 sendSm1;

	RSat::TSendSmV1Pckg sendSmPckg1(sendSm1);

	iSat.NotifySendSmPCmd(reqStatus1,sendSmPckg1);

	// Invoke 2-nd client RSat::NotifySendSmPCmd()

	TRequestStatus reqStatus2;

	RSat::TSendSmV1 sendSm2;

	RSat::TSendSmV1Pckg sendSmPckg2(sendSm2);

	sat2.NotifySendSmPCmd(reqStatus2,sendSmPckg2);

	User::WaitForRequest(reqStatus1);

	User::WaitForRequest(reqStatus2);

	// Check both results

	ASSERT_EQUALS(KErrNone, reqStatus1.Int());

	ASSERT_EQUALS(KErrNone, reqStatus2.Int()); // KErrNone or KErrServerBusy ? See the note at the top.     

	ASSERT_EQUALS(KTestPCmdNumber, sendSm1.PCmdNumber());

	ASSERT_EQUALS(KTestPCmdNumber, sendSm2.PCmdNumber());

	ASSERT_EQUALS(sendSm1.iAlphaId.iStatus, ExpectedAlphaIdStatus(ETestSequence11));

	ASSERT_EQUALS(sendSm2.iAlphaId.iStatus, ExpectedAlphaIdStatus(ETestSequence11));

	ASSERT_TRUE(sendSm1.iAlphaId.iAlphaId == ExpectedAlphaId(ETestSequence11));

	ASSERT_TRUE(sendSm2.iAlphaId.iAlphaId == ExpectedAlphaId(ETestSequence11));

	ASSERT_EQUALS(sendSm1.iAddress.iTypeOfNumber, ExpectedTypeOfNumber(ETestSequence11));

	ASSERT_EQUALS(sendSm2.iAddress.iTypeOfNumber, ExpectedTypeOfNumber(ETestSequence11));

	ASSERT_EQUALS(sendSm1.iAddress.iNumberPlan, ExpectedNumberPlan(ETestSequence11));

	ASSERT_EQUALS(sendSm2.iAddress.iNumberPlan, ExpectedNumberPlan(ETestSequence11));

	ASSERT_TRUE(sendSm1.iAddress.iTelNumber == KDialingNumberString16);

	ASSERT_TRUE(sendSm2.iAddress.iTelNumber == KDialingNumberString16);

	ASSERT_TRUE(sendSm1.iSmsTpdu == tpdu);		

	ASSERT_TRUE(sendSm2.iSmsTpdu == tpdu);		

	// Prime MOCK with appropriate "TERMINAL RESPONSE" 	

	RSat::TSendSmRspV1 rsp;

	RSat::TSendSmRspV1Pckg rspPckg(rsp);

	FillResponse(rsp,ETestSequence11);

	MockPrimeSendSmTerminalResponseL(ETestSequence11,rsp);

	// Invoke 1-st RSat:TerminalRsp	

	TRequestStatus rspStatus1;

	iSat.TerminalRsp(rspStatus1,RSat::ESendSm,rspPckg);

	User::WaitForRequest(rspStatus1);

	ASSERT_EQUALS(KErrNone, rspStatus1.Int());

	// Prime MOCK once again with "TERMINAL RESPONSE"

	MockPrimeSendSmTerminalResponseL(ETestSequence11,rsp);

	// Invoke 2-nd RSat:TerminalRsp

	TRequestStatus rspStatus2;

	sat2.TerminalRsp(rspStatus2,RSat::ESendSm,rspPckg);

	User::WaitForRequest(rspStatus2);

	ASSERT_EQUALS(KErrNone, rspStatus2.Int());

	AssertMockLtsyStatusL();

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

	}

// *************************** 

// * TLV tags used for testing

// ***************************

#if 1

// TLV tags without CR bit

const TUint8 KTestCommandDetailsTag  = KTlvCommandDetailsTag;

const TUint8 KTestDeviceIdentityTag  = KTlvDeviceIdentityTag;

const TUint8 KTestAlphaIdentifierTag = KTlvAlphaIdentifierTag;

const TUint8 KTestAddressTag         = KTlvAddressTag;

const TUint8 KTestSmsTpduTag         = KTlvSmsTpduTag;

const TUint8 KTestResultTag          = KTlvResultTag;

const TUint8 KTestIconIdentifierTag  = KTlvIconIdentifierTag;

#else

// TLV tags with CR (Comprehension Required) bit set. 

// It is not quite clear how exacly it should be used in "TERMINAL RESPONSE"

// but current SAT TSY implementation never sets it there for tags other 

// than "command details" though terminal responses listed in TS 31.124 have it set

// for all tags. Is that a defect ??

const TUint8 KTestCommandDetailsTag  = (KTlvCommandDetailsTag  | KTagCrMask);

const TUint8 KTestDeviceIdentityTag  = (KTlvDeviceIdentityTag  | KTagCrMask);

const TUint8 KTestAlphaIdentifierTag = (KTlvAlphaIdentifierTag | KTagCrMask);

const TUint8 KTestAddressTag         = (KTlvAddressTag | KTagCrMask);

const TUint8 KTestSmsTpduTag         = (KTlvSmsTpduTag | KTagCrMask);

const TUint8 KTestResultTag          = (KTlvResultTag  | KTagCrMask);

const TUint8 KTestIconIdentifierTag  = (KTlvIconIdentifierTag | KTagCrMask);

#endif

// ******************************

// * TLV values used for testing

// ******************************

// Type of address, see ETSI TS 102 223 (v8.1.0) clause 8.1

// Possible TON (i.e. "Type Of Number") values:

// 		0x00 (000) - Unknown

// 		0x01 (001) - International Number

// 		0x02 (010) - National Number

// 		0x03 (011) - Network Specific Number

//	the below values are defined in 3GPP TS 23.040 V8.2.0

//		0x04 (100) Subscriber number

//		0x05 (101) Alphanumeric, (coded according to 3GPP TS 23.038 [9] GSM 7-bit default alphabet)

//		0x06 (110) Abbreviated number

//		0x07 (111) Reserved for extension	

// Possible NPI (i.e. "Numbering Plan Identification") values:

// 		0x00 (0000) - Unknown

// 		0x01 (0001) - ISDN/telephony numbering plan (ITU-T Recommendations E.164 and E.163)

// 		0x03 (0011) - Data numbering plan (ITU-T Recommendation X.121)

// 		0x04 (0100) - Telex numbering plan (ITU-T Recommendation F.69)

// 		0x09 (1001) - Private numbering plan

// 		0x0F (1111) - Reserved for extension

//	the below values are defined in 3GPP TS 23.040 V8.2.0

//		0x05 (0101) Service Centre Specific plan

//		0x06 (0110) Service Centre Specific plan

//		0x08 (1000) National numbering plan

//		0x0A (1010) ERMES numbering plan (ETSI DE/PS 3 01-3)

const TUint8 KTestTypeOfAddress = (0x80 | (0x01 << 4) | 0x01); // International number + ISDN/telephony numbering plan   

// Icon identifier (a number of a record in EFimg)

const TUint8 KTestIconIdentifier = 1; 

// TP-Protocol-Identifier (TP-PID) values, see 3GPP TS 23.040 V8.2.0, clause 9.2.3.9

//		0x40 (01000000) Short Message Type 0

//		0x41 (01000001) Replace Short Message Type 1

//		0x42 (01000010) Replace Short Message Type 2

//		0x43 (01000011) Replace Short Message Type 3

//		0x44 (01000100) Replace Short Message Type 4

//		0x45 (01000101) Replace Short Message Type 5

//		0x46 (01000110) Replace Short Message Type 6

//		0x46 (01000111) Replace Short Message Type 7

//		0x5E (01011110) Enhanced Message Service (Obsolete)

//		0x5F (01011111) Return Call Message

//		0x7C (01111100) ANSI-136 R-DATA

//		0x7D (01111101) ME Data download

//		0x7E (01111110) ME De-personalization Short Message

//		0x7F (01111111) (U)SIM Data download

const TUint8 KShortMessageType0 = 0x40; //Short message type 0

//**********************

// Strings used in tests

//**********************

_LIT8(KDestinationAddressString8,"012345678");

_LIT8(KShortDestinationAddressString8,"01");

_LIT8(KTestMessageString8,"Test Message");

_LIT8(KSendSmString8,"Send SM");

_LIT16(KSendSmString16,"Send SM");

_LIT8(KShortMessageString8,"Short Message");

_LIT16(KShortMessageString16,"Short Message");

_LIT8(KNoIconString8,"NO ICON");

_LIT16(KNoIconString16,"NO ICON");

// GSM7 coded "Short Message"

_LIT8(KShortMessageStringGSM7,"\x53\xF4\x5B\x4E\x07\x35\xCB\xF3\x79\xF8\x5C\x06");

// GSM7 encoded "The address data object holds the RP_Destination_Address"

_LIT8(KSequence14AlphaString8,

"\x54\x68\x65\x20\x61\x64\x64\x72\x65\x73\x73\x20\x64\x61\x74\x61\

\x20\x6F\x62\x6A\x65\x63\x74\x20\x68\x6F\x6C\x64\x73\x20\x74\x68\

\x65\x20\x52\x50\x11\x44\x65\x73\x74\x69\x6E\x61\x74\x69\x6F\x6E\

\x11\x41\x64\x64\x72\x65\x73\x73"); 

_LIT(KSequence14AlphaString16,

"The address data object holds the RP_Destination_Address");

_LIT8(KSequence15AlphaString8,

"The address data object holds the RP Destination Address");

_LIT(KSequence15AlphaString16,

"The address data object holds the RP Destination Address");

_LIT8(KSequence16AlphaString8,

"Two types are defined: - A short message to be sent to the network in an \

SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can \

be passed transparently; - A short message to be sent to the network in an \

SMS-SUBMIT ");

_LIT(KSequence16AlphaString16,

"Two types are defined: - A short message to be sent to the network in an \

SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can \

be passed transparently; - A short message to be sent to the network in an \

SMS-SUBMIT ");

_LIT8(KLongUserDataString8,

"Two types are defined: - A short message to be sent to the network in an \

SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can \

be passed transp");

// GSM7 encoded K160CharsString 

//"Two types are defined: - A short message to be sent to the network in an " 

//"SMS-SUBMIT message, or an SMS-COMMAND message, where the user data can "

//"be passed transp"

_LIT8(KLongUserDataStringGSM7,

"\xD4\xFB\x1B\x44\xCF\xC3\xCB\x73\x50\x58\x5E\x06\

\x91\xCB\xE6\xB4\xBB\x4C\xD6\x81\x5A\xA0\x20\x68\

\x8E\x7E\xCB\xE9\xA0\x76\x79\x3E\x0F\x9F\xCB\x20\

\xFA\x1B\x24\x2E\x83\xE6\x65\x37\x1D\x44\x7F\x83\

\xE8\xE8\x32\xC8\x5D\xA6\xDF\xDF\xF2\x35\x28\xED\

\x06\x85\xDD\xA0\x69\x73\xDA\x9A\x56\x85\xCD\x24\

\x15\xD4\x2E\xCF\xE7\xE1\x73\x99\x05\x7A\xCB\x41\

\x61\x37\x68\xDA\x9C\xB6\x86\xCF\x66\x33\xE8\x24\

\x82\xDA\xE5\xF9\x3C\x7C\x2E\xB3\x40\x77\x74\x59\

\x5E\x06\xD1\xD1\x65\x50\x7D\x5E\x96\x83\xC8\x61\

\x7A\x18\x34\x0E\xBB\x41\xE2\x32\x08\x1E\x9E\xCF\

\xCB\x64\x10\x5D\x1E\x76\xCF\xE1");

_LIT8(KSingleSpaceUserData8," ");

// *********************

// Below TPDUs are taken from 3GPP TS 31.124 (see  SMS-PP (SEND SHORT MESSAGE) 

// codings for each test sequence where command qualifier is set to "packing required")

// The only difference is that MR values (the 2-nd byte) are "0" instead of "1" as 

// in the original document.

// *********************

_LIT8(KSequence12ExpectedTpdu,

"\x01\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\x07\xD3\xB2\x9B\x0C\x9A\x36\x01");

_LIT8(KSequence14ExpectedTpdu,

"\x01\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\

\xA0\xD4\xFB\x1B\x44\xCF\xC3\xCB\x73\x50\x58\x5E\

\x06\x91\xCB\xE6\xB4\xBB\x4C\xD6\x81\x5A\xA0\x20\

\x68\x8E\x7E\xCB\xE9\xA0\x76\x79\x3E\x0F\x9F\xCB\

\x20\xFA\x1B\x24\x2E\x83\xE6\x65\x37\x1D\x44\x7F\

\x83\xE8\xE8\x32\xC8\x5D\xA6\xDF\xDF\xF2\x35\x28\

\xED\x06\x85\xDD\xA0\x69\x73\xDA\x9A\x56\x85\xCD\

\x24\x15\xD4\x2E\xCF\xE7\xE1\x73\x99\x05\x7A\xCB\

\x41\x61\x37\x68\xDA\x9C\xB6\x86\xCF\x66\x33\xE8\

\x24\x82\xDA\xE5\xF9\x3C\x7C\x2E\xB3\x40\x77\x74\

\x59\x5E\x06\xD1\xD1\x65\x50\x7D\x5E\x96\x83\xC8\

\x61\x7A\x18\x34\x0E\xBB\x41\xE2\x32\x08\x1E\x9E\

\xCF\xCB\x64\x10\x5D\x1E\x76\xCF\xE1");

// *************************

// Fake TP-VP values used in

// *************************

_LIT8(KFakeRelativeValidityValue,"\x00");

_LIT8(KFakeAbsoluteOrEnchancedValidityValue,"\x00\x00\x00\x00\x00\x00\x00");

// *********************

// below 3 TPDUs are made of KSequence12ExpectedTpdu combined with 

// KFakeRelativeValidityValue and KFakeAbsoluteOrEnchancedValidityValue appropriately

// Once the above strings are changed the below should be changed too 

// *********************

_LIT8(KTestRelativeVPFPackedExpectedTpdu,

"\x11\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\x00\x07\xD3\xB2\x9B\x0C\x9A\x36\x01");

_LIT8(KTestEnchancedVPFPackedExpectedTpdu,

"\x09\x00\x09\x91\x10\x32\x54\x76\xF8\x40\xF0\x00\x00\x00\x00\x00\x00\x00\x07\xD3\xB2\x9B\x0C\x9A\x36\x01");

_LIT8(KTestAbsoluteVPFPackedExpectedTpdu,