// 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 CallControl in the Common TSY.

*/

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <test/tmockltsydata.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/ltsy/mltsydispatchpacketservicesinterface.h>

#include "config.h"

#include "mockltsyindicatorids.h"

#include <in_sock.h>

#include "cctsypacketservicesfunegative.h"

void CCTsyPacketServicesFUNegative::ConvertDNSToPCOBuffer

	(const TDes8& aPrimaryDNS, const TDes8& aSecondaryDNS, const TUint8 aRequestID, TDes8&  aFormatPcoBufferAddr)

	{

	// Handle Primary DNS address

	TInetAddr netPrimaryDNS;

	TBuf<KDnsLength> netPrimaryDNSConv;

	netPrimaryDNSConv.Copy(aPrimaryDNS);

	netPrimaryDNS.Input(netPrimaryDNSConv);

	TUint32 primDNSaddr =  netPrimaryDNS.Address();

	// Handle Secondary DNS address

	TInetAddr netSecondaryDNS;

	TBuf<KDnsLength> netSecondaryDNSConv;

	netSecondaryDNSConv.Copy(aSecondaryDNS);

	netSecondaryDNS.Input(netSecondaryDNSConv);

	TUint32 secondaryDNSaddr =  netSecondaryDNS.Address();

	aFormatPcoBufferAddr[0] = KPrimaryAndSecondaryDNSLength;	// Length

	aFormatPcoBufferAddr[1] = KIPCRequestCode; 					// IPC PRequest Code

	aFormatPcoBufferAddr[2] = aRequestID; 						// Request ID (CHAP challenge)

	aFormatPcoBufferAddr[3] = KPacketLengthMSB;					// Packet length MSB (always zero)

	aFormatPcoBufferAddr[4] = KPrimaryAndSecondaryDNSLength;	// Packet length LSB

	aFormatPcoBufferAddr[5] = KIndicatePrimaryAddress; 			// Indicate Primary address

	aFormatPcoBufferAddr[6]	= KDnsAddressLength;				// Length of address (inc header)

	aFormatPcoBufferAddr[7] = (primDNSaddr >> 24) & 0xff; 		// Primary DNS

	aFormatPcoBufferAddr[8] = (primDNSaddr >> 16) & 0xff; 		// Primary DNS

	aFormatPcoBufferAddr[9] = (primDNSaddr >> 8) & 0xff; 		// Primary DNS

	aFormatPcoBufferAddr[10] =  primDNSaddr & 0xff; 			// Primary DNS

	aFormatPcoBufferAddr[11] = KIndicateSecondaryAddress;		// Indicate Secondary address

	aFormatPcoBufferAddr[12] = KDnsAddressLength;				// Length of address (inc header)

	aFormatPcoBufferAddr[13] = (secondaryDNSaddr >> 24) & 0xff; // Secondary DNS

	aFormatPcoBufferAddr[14] = (secondaryDNSaddr >> 16) & 0xff; // Secondary DNS

	aFormatPcoBufferAddr[15] = (secondaryDNSaddr >> 8) & 0xff; 	// Secondary DNS

	aFormatPcoBufferAddr[16] =  secondaryDNSaddr & 0xff; 		// Secondary DNS

	aFormatPcoBufferAddr.SetLength(KPrimaryAndSecondaryDNSLength + 1);

	}

// Generates the username, password and requestID buffer as described in 3GPP specification 3G TS 24.008

void CCTsyPacketServicesFUNegative::ConvertUsernameAndPasswordToPCOBuffer(const TDes8& aUsername, 

		const TDes8& aPassword, const TUint8 aRequestID, TDes8& aFormatedBuffer)

	{

	TInt usernameLen = aUsername.Length();

	TInt passwordLen = aPassword.Length();

	TInt dataLen = usernameLen + passwordLen + KPasswordUsernameHeaderLength;

	TInt i = 0;

	aFormatedBuffer[i++] = dataLen; 				// Length

	aFormatedBuffer[i++] = KIPCRequestCode; 		// IPC PRequest Codeio

	aFormatedBuffer[i++] = aRequestID; 				// Request ID (CHAP challenge)

	aFormatedBuffer[i++] = KPacketLengthMSB; 		// Packet length MSB (always zero)

	aFormatedBuffer[i++] = dataLen; 				// Packet length LSB

	aFormatedBuffer[i++] = usernameLen; 			// Length of username

	aFormatedBuffer.SetLength(i);

	aFormatedBuffer.Append(aUsername); 				// Username

	aFormatedBuffer.SetLength(i + usernameLen + 1);

	aFormatedBuffer[i + usernameLen] = passwordLen; // Length of password

	aFormatedBuffer.Append(aPassword);				// Password

	}

/***

* 											PCO - Description

*

* The purpose of the protocol configuration options (PCO) is to transfer external network protocol options 

* associated with a PDP context activation, and transfer additional (protocol) data 

* (e.g. configuration parameters, error codes or messages/events) associated with an external protocol 

* or an application.

* The protocol configuration options (PCO) is a type 4 information element with a minimum length of 3 

* octets and a maximum length of 253 octets

* In order to generate the PCO buffer a TTlvStruct object is being used. The TTlvStruct wraps the buffers  

* inserted to the PCO and identifies the buffers with given IDs.

*  

* In the following test the PCO buffer is initiated with the username, password, requestID, 

* primary DNS and secondary DNS. In addition the PCO contains a Misc Buffer which has the 

* same structure and the same characteristics as the PCO buffer and can contain 

* Miscellaneous protocol information. The main risk with the Misc Buffer is an overflow 

* (The dispatcher handles the overflow scenario). 

*

* Following is an example of a PCO buffer outline:

*	

*	PcoBuffer[0] == 0x80);  // Config options ext bit

*	PcoBuffer[1] == 0xC0);  // Header 1

*	PcoBuffer[2] == 0x23);  // Header 2

*	PcoBuffer[3] == 0xC);   // Length

*	PcoBuffer[4] == 0x1);   // IPC PRequest Code

*	PcoBuffer[5] == 0x0);   // Request ID (CHAP challenge)

*	PcoBuffer[6] == 0x0);   // Packet length MSB (always zero)

*	PcoBuffer[7] == 0xC);   // Packet length LSB

*	PcoBuffer[8] == 0x3);   // Length of username

*	PcoBuffer[9] == 119);   // Username

*	PcoBuffer[10] == 101);  // Username

*	PcoBuffer[11] == 98);   // Username

*	PcoBuffer[12] == 0x3);  // Length of password

*	PcoBuffer[13] == 119);  // Password

*	PcoBuffer[14] == 101);  // Password

*	PcoBuffer[15] == 98);   // Password

*	PcoBuffer[16] == 0x80); // DNS HeaderId 1

*	PcoBuffer[17] == 0x21); // DNS HeaderId 2

*	PcoBuffer[18] == 0x10); // Length

*	PcoBuffer[19] == 0x1);  // IPC PRequest Code

*	PcoBuffer[20] == 0x1);  // Request ID (CHAP challenge)

*	PcoBuffer[21] == 0x0);  // Packet length MSB (always zero)  

*	PcoBuffer[22] == 0x10); // Packet length LSB

*	PcoBuffer[23] == 0x81); // Indicate Primary address 

*	PcoBuffer[24] == 0x6);  // Length of address (inc header)        

*	PcoBuffer[25] == 0xBE); // Primary DNS

*	PcoBuffer[26] == 0x0);  // Primary DNS

*	PcoBuffer[27] == 0x65); // Primary DNS

*	PcoBuffer[28] == 0xBD); // Primary DNS               

*	PcoBuffer[29] == 0x83); // Indicate Secondary address 

*	PcoBuffer[30] == 0x6);  // Length of address (inc header)     

*	PcoBuffer[31] == 0x19); // Secondary DNS

*	PcoBuffer[32] == 0x5);  // Secondary DNS

*	PcoBuffer[33] == 0x28); // Secondary DNS

*	PcoBuffer[34] == 0xBF); // Secondary DNS

*   

*   The Misc buffer should be added after the secondary DNS value (i.e. location 35 in the

*   example above).      

*/

// 

//

//

// Generates a PCO buffer out of a PCO object.

void CCTsyPacketServicesFUNegative::PCOGeneratorL(RPacketContext::TProtocolConfigOptionV2& aPco, RPacketContext::TMiscProtocolBuffer& aPcoBuffer)

	{

	TBuf8<KMaxUserAndPassLength> userAndPasswordBuffer(KMaxUserAndPassLength);

	// Generates the username, password and requestID buffer as described in 3GPP specification 3G TS 24.008

	ConvertUsernameAndPasswordToPCOBuffer(aPco.iAuthInfo.iUsername, aPco.iAuthInfo.iPassword, aPco.iId++, userAndPasswordBuffer);

	TPtr8 userAndPasswordParamDataPtr(const_cast<TUint8*>(userAndPasswordBuffer.Ptr()),

			userAndPasswordBuffer.Length(), userAndPasswordBuffer.Length());

	TBuf8<KMaxPdpAddressLength> primaryAndSecondaryDNSBuffer(KPrimaryAndSecondaryDNSLength + 1);

	// Generates the primary and secondary DNS buffer as described in 3GPP specification 3G TS 24.008

	ConvertDNSToPCOBuffer(aPco.iDnsAddresses.iPrimaryDns, aPco.iDnsAddresses.iSecondaryDns, aPco.iId++, primaryAndSecondaryDNSBuffer);

	// Setting the configurations buffers

	TPtr8 primaryAndSecondaryDNSParamDataPtr(const_cast<TUint8*>(primaryAndSecondaryDNSBuffer.Ptr()),

				primaryAndSecondaryDNSBuffer.Length(), primaryAndSecondaryDNSBuffer.Length());

	TPtr8 pcoPtr (const_cast<TUint8*> (aPcoBuffer.Ptr()), RPacketContext::KMiscProtocolBufferLength);

	TTlvStruct<RPacketContext::TPcoId, RPacketContext::TPcoItemDataLength> pcoTlv(pcoPtr,0);

	RPacketContext::TPcoId usenameAndPasswordID(KUsenamePasswordDNSID);

	RPacketContext::TPcoId primaryAndSecondaryDNSID(KPrimaryAndSecondaryDNSID);

	pcoTlv.AppendItemL(usenameAndPasswordID, userAndPasswordParamDataPtr);

	pcoTlv.AppendItemL(primaryAndSecondaryDNSID, primaryAndSecondaryDNSParamDataPtr);

	aPcoBuffer.SetLength(primaryAndSecondaryDNSParamDataPtr.Length() + userAndPasswordParamDataPtr.Length() + 2 * KIDLength);

	// Append the misc buffer which is alread in TLV structure

	aPcoBuffer.Append(aPco.iMiscBuffer);

	}

void CCTsyPacketServicesFUNegative::DriverDeleteContextL(TInfoName aContextName)

	{

	RBuf8 data;

	CleanupClosePushL(data);

	TMockLtsyData1<TInfoName> contextNameData(aContextName);

	data.Close();

	contextNameData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, data, KErrNone);

	CleanupStack::PopAndDestroy(1, &data); // data

	}

void CCTsyPacketServicesFUNegative::DriverAttachPacketServiceL()

	{

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId);

	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId, KErrNone);

	}

void CCTsyPacketServicesFUNegative::DriverDetachPacketServiceL()

	{

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId);

	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId, KErrNone);

	// SetAttachModeL being called as part of the detach completion process

	RBuf8 dataExpect;

    CleanupClosePushL(dataExpect);

    RPacketService::TAttachMode attachMode = RPacketService::EAttachWhenPossible;

    TMockLtsyData1<RPacketService::TAttachMode> ltsyData(attachMode);

    dataExpect.Close();

    ltsyData.SerialiseL(dataExpect);

    iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPacketAttachMode::KLtsyDispatchPacketServicesSetPacketAttachModeApiId, dataExpect, KErrNone);

    iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPacketAttachMode::KLtsyDispatchPacketServicesSetPacketAttachModeApiId, KErrNone);

	CleanupStack::PopAndDestroy(1, &dataExpect); // dataExpect

	}

void CCTsyPacketServicesFUNegative::DriverInitialiseContextL()

	{

	RBuf8 data;

	CleanupClosePushL(data);

	TInfoName primaryContext;

	TInfoName secondaryContext;

	primaryContext.Copy(KFirstAllocatedContextName);

	secondaryContext.Copy(KDefaultContextName);

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

	// Successful completion request of

	// RPacketContext::InitialiseContext

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

	TMockLtsyData2<TInfoName, TInfoName> expLtsyContextNamesData3(primaryContext, secondaryContext);

	data.Close();

	expLtsyContextNamesData3.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId, data);

	TDesC* contextNamePtr = &primaryContext;

	TDesC* channelIdPtr = const_cast<TDesC*>(&KDefaultChannelId);

	TMockLtsyData2<TDesC*, TDesC*> expLtsyContextNameAndChannelIdData(contextNamePtr, channelIdPtr);

	data.Close();

	expLtsyContextNameAndChannelIdData.SerialiseL(data);

	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId, KErrNone, data);

	CleanupStack::PopAndDestroy(1, &data); // data

	}

void CCTsyPacketServicesFUNegative::DriverInitialiseContextL(const TInfoName& aPrimaryContextId, const TInfoName& aSecondaryContextId)

	{

	RBuf8 data;

	CleanupClosePushL(data);

	TInfoName& primaryContext = const_cast<TInfoName&>(aPrimaryContextId);

	TInfoName& secondaryContext = const_cast<TInfoName&>(aSecondaryContextId);

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

	// Successful completion request of

	// RPacketContext::InitialiseContext

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

	TMockLtsyData2<TInfoName, TInfoName> expLtsyContextNamesData(primaryContext, secondaryContext);

	data.Close();

	expLtsyContextNamesData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId, data);

	// Check if a secondary context is being initialise and if it is then compelte initialisation for secondary context.

	TDesC* contextNamePtr = (aSecondaryContextId == KDefaultContextName) ? &primaryContext : &secondaryContext;

	TDesC* channelIdPtr = const_cast<TDesC*>(&KSecondaryContextChannelId);

	TMockLtsyData2<TDesC*, TDesC*> expLtsyContextNameAndPortData2(contextNamePtr, channelIdPtr);

	data.Close();

	expLtsyContextNameAndPortData2.SerialiseL(data);	

	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId, KErrNone, data);

	CleanupStack::PopAndDestroy(&data); // data

	}

void CCTsyPacketServicesFUNegative::DriverSetConfigContextL(TInfoName aContextId,

		RPacketContext::TGSNAddress aAccessPoint, RPacketContext::TProtocolType aPdpType, 

		RPacketContext::TProtocolAddress aPdpAddress,

		RPacketContext::TMiscProtocolBuffer aPcoBuffer)

	{

	RBuf8 data;

	CleanupClosePushL(data);

	TMockLtsyData5<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolType, RPacketContext::TProtocolAddress, RPacketContext::TMiscProtocolBuffer>

					packetSetConfigData(aContextId, aAccessPoint, aPdpType, aPdpAddress, aPcoBuffer);

	data.Close();

	packetSetConfigData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextConfig::KLtsyDispatchPacketServicesSetPdpContextConfigApiId, data, KErrNone);

	// Indicate that the context name is due to comeback from the SetConfig callback

	TInfoName callbackContextId = aContextId;

	TMockLtsyData1<TInfoName> callbackContextIdData(callbackContextId);

	data.Close();

	callbackContextIdData.SerialiseL(data);

	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextConfig::KLtsyDispatchPacketServicesSetPdpContextConfigApiId, KErrNone, data);

	CleanupStack::PopAndDestroy(1, &data); // data

	}

void CCTsyPacketServicesFUNegative::DriverModifyActiveContextL(TInt8 aRejectionCode, TInt aError)

	{

	RBuf8 data;

	CleanupClosePushL(data);

	TInfoName modifyActiveContextName;

	modifyActiveContextName.Copy(KFirstAllocatedContextName);

	TMockLtsyData1<TInfoName>

		modifyActiveContextNameData(modifyActiveContextName);

	data.Close();

	modifyActiveContextNameData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesModifyActivePdpContext::KLtsyDispatchPacketServicesModifyActivePdpContextApiId, data, KErrNone);

	TMockLtsyData2<TInfoName, TInt8 >

		completeModifyActiveContextData(modifyActiveContextName, aRejectionCode); // Context name and rejection code

	data.Close();

	completeModifyActiveContextData.SerialiseL(data);

	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesModifyActivePdpContext::KLtsyDispatchPacketServicesModifyActivePdpContextApiId, aError, data);

	CleanupStack::PopAndDestroy(1, &data); // data

	}

void CCTsyPacketServicesFUNegative::OpenInitialiseMbmsContextLC(RPacketService& aPacketService, RPacketMbmsContext& aPacketContext, TDes& aContextName, const TDesC& aChannelId, TInt aCompError)

	{

	aPacketContext.OpenNewContext(aPacketService, aContextName);

	CleanupClosePushL(aPacketContext);

	RBuf8 data;

	CleanupClosePushL(data);

	TDesC* contextNamePtr = &aContextName;

	TMockLtsyData1<TDesC*> initMbmdContextExpData(contextNamePtr);

	initMbmdContextExpData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesInitialiseMbmsContext::KLtsyDispatchPacketServicesInitialiseMbmsContextApiId, data);

	data.Close();

	TDesC* channelPtr = const_cast<TDesC*>(&aChannelId);

	TMockLtsyData2<TDesC*,TDesC*> initMbmdContextCompData(contextNamePtr, channelPtr);

	initMbmdContextCompData.SerialiseL(data);

	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesInitialiseMbmsContext::KLtsyDispatchPacketServicesInitialiseMbmsContextApiId, aCompError, data);

	data.Close();

	//initialisation of the context

	RPacketContext::TDataChannelV2 dataChannel;

	RPacketContext::TDataChannelV2Pckg dataChannelPckg(dataChannel);

	TRequestStatus requestStatus;

    aPacketContext.InitialiseContext(requestStatus, dataChannelPckg);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(requestStatus.Int(), aCompError);

	ASSERT_TRUE((aCompError != KErrNone) || (dataChannel.iChannelId == aChannelId));

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(&data);

	}

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

	{

	SUB_SUITE;

  	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0004L);	

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0012L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0013L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0014L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0015L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0016L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0018L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0019L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0020L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0021L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0022L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0023L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0024L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0025L);

	END_SUITE;

	}

//

// 'Negative' unit tests

//

/**

@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0001

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EPacketAttach is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RPacketService::Attach()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPacketServicesFUNegative::TestUnit0001L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	TRequestStatus requestStatus;

	RPacketService packetService;

	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

    packetService.Attach(requestStatus);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrGsmMMNetworkFailure, requestStatus.Int());

	packetService.Close();

	AssertMockLtsyStatusL();

	config.Reset();

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

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0002

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EPacketGetAttachMode is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RPacketService::GetAttachMode()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPacketServicesFUNegative::TestUnit0002L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPacketServicesGetPacketAttachMode::KLtsyDispatchPacketServicesGetPacketAttachModeApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	TRequestStatus requestStatus;

	RPacketService packetService;

	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

	RPacketService::TAttachMode completedAttachMode;

	packetService.GetAttachMode(requestStatus, completedAttachMode);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	packetService.Close();

	AssertMockLtsyStatusL();

	config.Reset();

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

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0003

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EPacketGetNtwkRegStatus is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RPacketService::GetNtwkRegStatus()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPacketServicesFUNegative::TestUnit0003L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus::KLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatusApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();