--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsypacketservicesfunegative.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,2444 @@
+// 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();
+	
+	TRequestStatus requestStatus;
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+	
+	RPacketService::TRegistrationStatus registrationStatus;
+
+	packetService.GetNtwkRegStatus(requestStatus, registrationStatus);
+	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-UN0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketDetach is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::Detach()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0004L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+	
+    TRequestStatus mockLtsyStatus;
+    iMockLTSY.NotifyTerminated(mockLtsyStatus);
+    iMockLTSY.CompleteL(MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId, KErrNone);
+    User::WaitForRequest(mockLtsyStatus);
+    AssertMockLtsyStatusL();
+    
+    TRequestStatus requestStatus;
+    packetService.Detach(requestStatus);
+    User::WaitForRequest(requestStatus);
+    AssertMockLtsyStatusL();
+    ASSERT_EQUALS(KErrGsmMMNetworkFailure, requestStatus.Int());
+
+	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(2, this); // packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextSetConfig is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::SetConfig()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0005L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesSetPdpContextConfig::KLtsyDispatchPacketServicesSetPdpContextConfigApiId, EFalse);
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+
+	// Prepare context configuration fo GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRS;
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);
+
+	// Create the PCO buffer
+	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;
+	gprsMiscBuffer.Zero();
+
+	// Generate a PCO buffer
+	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+
+	//
+
+	DriverInitialiseContextL();
+
+	// GPRS Configuration
+	TInfoName contextName;
+	contextName.Copy(KFirstAllocatedContextName);
+
+	DriverDeleteContextL(contextName);
+
+	//
+
+	// client side test
+	RPacketContext packetContext;
+
+	// Open a new context
+	TInt err = packetContext.OpenNewContext(packetService, contextName);
+	CleanupClosePushL(packetContext);
+	ASSERT_EQUALS(KErrNone, err);
+
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+	TRequestStatus initialiseContextStatus;
+
+	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);
+	User::WaitForRequest(initialiseContextStatus);
+
+	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);
+
+	TRequestStatus setConfigStatus;
+
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNotSupported, setConfigStatus.Int());
+
+	packetContext.Close();
+	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextModifyActiveContext is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::ModifyActiveContext()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0006L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesModifyActivePdpContext::KLtsyDispatchPacketServicesModifyActivePdpContextApiId, EFalse);
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+
+	// Prepare context configuration fo GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRS;
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);
+
+	// Create the PCO buffer
+	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;
+	gprsMiscBuffer.Zero();
+
+	// Generate a PCO buffer
+	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+
+	//
+
+	DriverInitialiseContextL();
+
+	// GPRS Configuration
+	TInfoName contextName;
+	contextName.Copy(KFirstAllocatedContextName);
+
+	DriverSetConfigContextL(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType,
+			setConfigGPRS.iPdpAddress, gprsMiscBuffer);
+
+	RPacketQoS::TQoSGPRSRequested qosExpectedRequestedGPRSProfile;
+
+	qosExpectedRequestedGPRSProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosExpectedRequestedGPRSProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSData(contextName,
+			qosExpectedRequestedGPRSProfile);
+	data.Close();
+	packetSetConfigGPRSData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);
+
+	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextName);
+	data.Close();
+	callbackSetPdpGPRSContextNameData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);
+
+	//Activate
+	TMockLtsyData1<TInfoName> expectedActivateContextNameData(contextName);
+	data.Close();
+	expectedActivateContextNameData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, data, KErrNone);
+
+	TMockLtsyData3<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolType>
+	completedActivateContextNameData(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType);
+	data.Close();
+	completedActivateContextNameData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, KErrNone, data);
+
+	RPacketQoS::TQoSGPRSNegotiated completedProfile;
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSNegotiated>
+				expLtsyQosProfileChangedInd(contextName, completedProfile);
+	data.Close();
+	expLtsyQosProfileChangedInd.SerialiseL(data);
+	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyQosProfileChangedIndId, KErrNone, data);
+
+	// Prepare context configuration for GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRSActive;
+	setConfigGPRSActive.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRSActive.iPdpType = RPacketContext::EPdpTypeIPv6;
+	setConfigGPRSActive.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+
+	TMockLtsyData5<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolAddress, TUint, RPacketContext::TMiscProtocolBuffer>
+					expLtsyProfileChangedInd(contextName, setConfigGPRS.iAccessPointName,
+							setConfigGPRS.iPdpAddress, setConfigGPRS.iPdpCompression, gprsMiscBuffer);
+	data.Close();
+	expLtsyProfileChangedInd.SerialiseL(data);
+
+	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyPdpContextConfigChangedIndId, KErrNone, data);
+
+	DriverSetConfigContextL(contextName, setConfigGPRSActive.iAccessPointName, setConfigGPRSActive.iPdpType,
+			setConfigGPRSActive.iPdpAddress, gprsMiscBuffer);
+
+	TMockLtsyData1<TInfoName> deactivateContextNameData(contextName);
+	data.Close();
+	deactivateContextNameData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, data, KErrNone);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, KErrNone, data);
+
+	DriverDeleteContextL(contextName);
+
+	//
+
+	// client side test
+	RPacketContext packetContext;
+
+	// Open a new context
+	TInt err = packetContext.OpenNewContext(packetService, contextName);
+	CleanupClosePushL(packetContext);
+	ASSERT_EQUALS(KErrNone, err);
+
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+	TRequestStatus initialiseContextStatus;
+
+	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);
+	User::WaitForRequest(initialiseContextStatus);
+
+	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);
+
+	TRequestStatus setConfigStatus;
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);
+
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());
+
+	TName qosName;
+	RPacketQoS packetQoS;
+	packetQoS.OpenNewQoS(packetContext, qosName);
+	CleanupClosePushL(packetQoS);
+
+	//
+    // SetProfileParameters for GPRS Configurations
+    //
+
+	RPacketQoS::TQoSGPRSRequested qosGPRSRequestedProfile;
+	qosGPRSRequestedProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosGPRSRequestedProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	TPckg< RPacketQoS::TQoSGPRSRequested > profilePckgGPRS(qosGPRSRequestedProfile);
+
+	TRequestStatus notifyProfileChangeStatus;
+	RPacketQoS::TQoSGPRSNegotiated profile;
+	TPckg<RPacketQoS::TQoSGPRSNegotiated> qosGPRSNegotiatedProfilePk(profile);
+	packetQoS.NotifyProfileChanged(notifyProfileChangeStatus, qosGPRSNegotiatedProfilePk);
+
+	TRequestStatus requestStatusGPRS;
+	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);
+	User::WaitForRequest(requestStatusGPRS);
+	ASSERT_EQUALS(KErrNone, requestStatusGPRS.Int());
+
+	//
+
+	RPacketContext::TContextConfigGPRS setConfigGPRSActiveNotifyConfigChanged;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRSNotifyConfigChanged(setConfigGPRSActiveNotifyConfigChanged);
+
+	TRequestStatus contextConfigStatus;
+	packetContext.NotifyConfigChanged(contextConfigStatus, pckgConfigGPRSNotifyConfigChanged);
+
+	TRequestStatus contextActivatingRequestStatus;
+	RPacketContext::TContextStatus contextStatus;
+	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);
+
+	TRequestStatus activateStatus;
+	packetContext.Activate(activateStatus);
+	User::WaitForRequest(activateStatus);
+	User::WaitForRequest(contextActivatingRequestStatus);
+	ASSERT_EQUALS(KErrNone, activateStatus.Int());
+	ASSERT_EQUALS(RPacketContext::EStatusActivating, contextStatus);
+
+	// Complete NotifyProfileChanged
+	User::WaitForRequest(notifyProfileChangeStatus);
+	ASSERT_EQUALS(KErrNone, notifyProfileChangeStatus.Int());
+
+	// Status change from RPacketContext::EStatusActivating to RPacketContext::EStatusActive
+	TRequestStatus contextActivateRequestStatus;
+	RPacketContext::TContextStatus contextActiveStatus;
+	packetContext.NotifyStatusChange(contextActivateRequestStatus, contextActiveStatus);
+
+	User::WaitForRequest(contextActivateRequestStatus);
+	ASSERT_EQUALS(KErrNone, contextActivateRequestStatus.Int());
+	ASSERT_EQUALS(RPacketContext::EStatusActive, contextActiveStatus);
+
+	// Prepare context configuration for GPRS
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv6;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS2(setConfigGPRS);
+
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS2);
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());
+
+	/* Request modification, modification should be successful */
+	TRequestStatus modifyActiveContextStatus;
+	packetContext.ModifyActiveContext(modifyActiveContextStatus);
+	User::WaitForRequest(modifyActiveContextStatus);
+	ASSERT_EQUALS(KErrNotSupported, modifyActiveContextStatus.Int());
+
+	TRequestStatus deactivateContextStatus;
+	packetContext.Deactivate(deactivateContextStatus);
+	User::WaitForRequest(deactivateContextStatus);
+	ASSERT_EQUALS(KErrNone, deactivateContextStatus.Int())
+
+	packetQoS.Close();
+	packetContext.Close();
+	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(5, this); // data, packetQoS, packetService, packetContext, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextInitialiseContext is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::InitialiseContext()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0007L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+
+	TInfoName contextName;
+	contextName.Copy(KFirstAllocatedContextName);
+	
+	DriverDeleteContextL(contextName);
+	
+	//Open a New Packet Context
+	RPacketContext packetContext;
+	CleanupClosePushL(packetContext);
+
+	TInt err = packetContext.OpenNewContext(packetService,contextName);
+	ASSERT_EQUALS(KErrNone, err);
+
+	TRequestStatus requestStatus;
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+
+	packetContext.InitialiseContext(requestStatus,dataChannelPk);
+	User::WaitForRequest(requestStatus);
+    ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);
+
+	packetContext.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();	
+	CleanupStack::PopAndDestroy(3, this); // packetService, packetContext, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextDelete is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Delete()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0008L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+		
+
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+
+	// Prepare context configuration fo GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRS;
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);
+
+	// Create the PCO buffer
+	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;
+	gprsMiscBuffer.Zero();
+
+	// Generate a PCO buffer
+	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+
+	//
+
+	DriverInitialiseContextL();
+
+	// GPRS Configuration
+	TInfoName contextName;
+	contextName.Copy(KFirstAllocatedContextName);
+
+	//
+
+	// client side test
+	RPacketContext packetContext;
+
+	// Open a new context
+	TInt err = packetContext.OpenNewContext(packetService, contextName);
+	CleanupClosePushL(packetContext);
+	ASSERT_EQUALS(KErrNone, err);
+
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+	TRequestStatus initialiseContextStatus;
+
+	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);
+	User::WaitForRequest(initialiseContextStatus);
+
+	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);
+
+	TRequestStatus setConfigStatus;
+
+	packetContext.Delete(setConfigStatus);
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNotSupported, setConfigStatus.Int());
+
+	// Close is not called since it invokes EPacketContextDelete
+	//	packetContext.Close();
+	//	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // packetService, packetContext, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketSetAttachMode is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::SetAttachMode()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0009L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesSetPacketAttachMode::KLtsyDispatchPacketServicesSetPacketAttachModeApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+	
+	TRequestStatus requestStatus;
+	RPacketService::TAttachMode attachMode = RPacketService::EAttachWhenPossible;
+    
+	packetService.SetAttachMode(requestStatus, attachMode);	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+    AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(2, this); // packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0010
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketNotifyStatusChange - *Notify* NOT NEEDED
+@SYMTestPriority High
+@SYMTestActions Invokes 
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0010L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesNotifyPacketStatusChange::KLtsyDispatchPacketServicesNotifyPacketStatusChangeApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(this); // , this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketSetDefaultContextParams is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::SetDefaultContextParams()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0011L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams::KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId, EFalse);
+	// or MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params::KLtsyDispatchPacketServicesSetDefaultPdpContextR99R4ParamsApiId
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+
+	RPacketContext::TContextConfigGPRS defaultGprsContextConfig;
+	defaultGprsContextConfig.iAccessPointName = KDefaultAccessPoint;
+	defaultGprsContextConfig.iPdpType = KDefaultPdpType;
+	TPckg<RPacketContext::TContextConfigGPRS> defaultContextGprsConfigPckg(defaultGprsContextConfig);
+	
+	TRequestStatus requestStatus;
+	packetService.SetDefaultContextParams(requestStatus, defaultContextGprsConfigPckg);
+	User::WaitForRequest(requestStatus);
+    ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);
+
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(2, this); // packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextActivate is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Activate()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0012L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+
+	// Prepare context configuration fo GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRS;
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);
+
+	// Create the PCO buffer
+	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;
+	gprsMiscBuffer.Zero();
+
+	// Generate a PCO buffer
+	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+
+	//
+
+	DriverInitialiseContextL();
+
+	// GPRS Configuration
+	TInfoName contextName;
+	contextName.Copy(KFirstAllocatedContextName);
+
+	DriverSetConfigContextL(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType,
+			setConfigGPRS.iPdpAddress, gprsMiscBuffer);
+
+	RPacketQoS::TQoSGPRSRequested qosExpectedRequestedGPRSProfile;
+
+	qosExpectedRequestedGPRSProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosExpectedRequestedGPRSProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSData(contextName,
+			qosExpectedRequestedGPRSProfile);
+	data.Close();
+	packetSetConfigGPRSData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);
+
+	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextName);
+	data.Close();
+	callbackSetPdpGPRSContextNameData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);
+
+	DriverDeleteContextL(contextName);
+
+	//
+
+	// client side test
+	RPacketContext packetContext;
+
+	// Open a new context
+	TInt err = packetContext.OpenNewContext(packetService, contextName);
+	CleanupClosePushL(packetContext);
+	ASSERT_EQUALS(KErrNone, err);
+
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+	TRequestStatus initialiseContextStatus;
+
+	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);
+	User::WaitForRequest(initialiseContextStatus);
+
+	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);
+
+	TRequestStatus setConfigStatus;
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);
+
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());
+
+	TName qosName;
+	RPacketQoS packetQoS;
+	packetQoS.OpenNewQoS(packetContext, qosName);
+	CleanupClosePushL(packetQoS);
+
+	//
+    // SetProfileParameters for GPRS Configurations
+    //
+
+	RPacketQoS::TQoSGPRSRequested qosGPRSRequestedProfile;
+	qosGPRSRequestedProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosGPRSRequestedProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	TPckg< RPacketQoS::TQoSGPRSRequested > profilePckgGPRS(qosGPRSRequestedProfile);
+
+	TRequestStatus requestStatusGPRS;
+	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);
+	User::WaitForRequest(requestStatusGPRS);
+	ASSERT_EQUALS(KErrNone, requestStatusGPRS.Int());
+
+	TRequestStatus requestStatus;
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);
+
+	packetQoS.Close();
+	packetContext.Close();
+	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(5, this); // data, packetQoS, packetService, packetContext, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketQoSSetProfileParams is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketQoS::SetProfileParameters()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0013L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, EFalse);
+//	or	MLtsyDispatchPacketServicesSetPdpContextQosR99R4::KLtsyDispatchPacketServicesSetPdpContextQosR99R4ApiId
+//	or	MLtsyDispatchPacketServicesSetPdpContextQosR5::KLtsyDispatchPacketServicesSetPdpContextQosR5ApiId
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+
+	// Prepare context configuration fo GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRS;
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);
+
+	// Create the PCO buffer
+	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;
+	gprsMiscBuffer.Zero();
+
+	// Generate a PCO buffer
+	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+
+	//
+
+	DriverInitialiseContextL();
+
+	// GPRS Configuration
+	TInfoName contextName;
+	contextName.Copy(KFirstAllocatedContextName);
+
+	DriverSetConfigContextL(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType,
+			setConfigGPRS.iPdpAddress, gprsMiscBuffer);
+
+	RPacketQoS::TQoSGPRSRequested qosExpectedRequestedGPRSProfile;
+
+	qosExpectedRequestedGPRSProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosExpectedRequestedGPRSProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSData(contextName,
+			qosExpectedRequestedGPRSProfile);
+	data.Close();
+	packetSetConfigGPRSData.SerialiseL(data);
+//	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);
+
+	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextName);
+	data.Close();
+	callbackSetPdpGPRSContextNameData.SerialiseL(data);
+//	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);
+
+	DriverDeleteContextL(contextName);
+
+	//
+
+	// client side test
+	RPacketContext packetContext;
+
+	// Open a new context
+	TInt err = packetContext.OpenNewContext(packetService, contextName);
+	CleanupClosePushL(packetContext);
+	ASSERT_EQUALS(KErrNone, err);
+
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+	TRequestStatus initialiseContextStatus;
+
+	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);
+	User::WaitForRequest(initialiseContextStatus);
+
+	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);
+
+	TRequestStatus setConfigStatus;
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);
+
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());
+
+	TName qosName;
+	RPacketQoS packetQoS;
+	packetQoS.OpenNewQoS(packetContext, qosName);
+	CleanupClosePushL(packetQoS);
+
+	//
+    // SetProfileParameters for GPRS Configurations
+    //
+
+	RPacketQoS::TQoSGPRSRequested qosGPRSRequestedProfile;
+	qosGPRSRequestedProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosGPRSRequestedProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	TPckg< RPacketQoS::TQoSGPRSRequested > profilePckgGPRS(qosGPRSRequestedProfile);
+
+	// in CMmPacketQoSGsmWcdmaExt::SetProfileParametersL()
+	// resullt of iMmPacketService->MessageManager()->HandleRequestL()
+	// is never checked
+	TRequestStatus requestStatusGPRS;
+	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);
+	User::WaitForRequest(requestStatusGPRS);
+	ASSERT_EQUALS(KErrNotSupported, requestStatusGPRS.Int());
+
+	packetQoS.Close();
+	packetContext.Close();
+	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(5, this); // data, packetQoS, packetService, packetContext, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketRejectActivationRequest is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::RejectActivationRequest()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0014L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest::KLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequestApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+
+	TRequestStatus requestStatus;
+	
+	packetService.RejectActivationRequest(requestStatus);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(2, this); // packetService, data
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0015
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextDeactivate is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Deactivate()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0015L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+
+	// Prepare context configuration fo GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRS;
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);
+
+	// Create the PCO buffer
+	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;
+	gprsMiscBuffer.Zero();
+
+	// Generate a PCO buffer
+	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);
+	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;
+
+	//
+
+	DriverInitialiseContextL();
+
+	// GPRS Configuration
+	TInfoName contextName;
+	contextName.Copy(KFirstAllocatedContextName);
+
+	DriverSetConfigContextL(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType,
+			setConfigGPRS.iPdpAddress, gprsMiscBuffer);
+
+	RPacketQoS::TQoSGPRSRequested qosExpectedRequestedGPRSProfile;
+
+	qosExpectedRequestedGPRSProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosExpectedRequestedGPRSProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSData(contextName,
+			qosExpectedRequestedGPRSProfile);
+	data.Close();
+	packetSetConfigGPRSData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);
+
+	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextName);
+	data.Close();
+	callbackSetPdpGPRSContextNameData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);
+
+	//Activate
+	TMockLtsyData1<TInfoName> expectedActivateContextNameData(contextName);
+	data.Close();
+	expectedActivateContextNameData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, data, KErrNone);
+
+	TMockLtsyData3<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolType>
+	completedActivateContextNameData(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType);
+	data.Close();
+	completedActivateContextNameData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, KErrNone, data);
+
+	RPacketQoS::TQoSGPRSNegotiated completedProfile;
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSNegotiated>
+				expLtsyQosProfileChangedInd(contextName, completedProfile);
+	data.Close();
+	expLtsyQosProfileChangedInd.SerialiseL(data);
+	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyQosProfileChangedIndId, KErrNone, data);
+
+	// Prepare context configuration for GPRS
+	RPacketContext::TContextConfigGPRS setConfigGPRSActive;
+	setConfigGPRSActive.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRSActive.iPdpType = RPacketContext::EPdpTypeIPv6;
+	setConfigGPRSActive.iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+
+	TMockLtsyData5<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolAddress, TUint, RPacketContext::TMiscProtocolBuffer>
+					expLtsyProfileChangedInd(contextName, setConfigGPRS.iAccessPointName,
+							setConfigGPRS.iPdpAddress, setConfigGPRS.iPdpCompression, gprsMiscBuffer);
+	data.Close();
+	expLtsyProfileChangedInd.SerialiseL(data);
+
+	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyPdpContextConfigChangedIndId, KErrNone, data);
+
+
+	DriverSetConfigContextL(contextName, setConfigGPRSActive.iAccessPointName, setConfigGPRSActive.iPdpType,
+			setConfigGPRSActive.iPdpAddress, gprsMiscBuffer);
+
+	DriverDeleteContextL(contextName);
+
+	//
+
+	// client side test
+	RPacketContext packetContext;
+
+	// Open a new context
+	TInt err = packetContext.OpenNewContext(packetService, contextName);
+	CleanupClosePushL(packetContext);
+	ASSERT_EQUALS(KErrNone, err);
+
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+	TRequestStatus initialiseContextStatus;
+
+	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);
+	User::WaitForRequest(initialiseContextStatus);
+
+	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);
+
+	TRequestStatus setConfigStatus;
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);
+
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());
+
+	TName qosName;
+	RPacketQoS packetQoS;
+	packetQoS.OpenNewQoS(packetContext, qosName);
+	CleanupClosePushL(packetQoS);
+
+	//
+    // SetProfileParameters for GPRS Configurations
+    //
+
+	RPacketQoS::TQoSGPRSRequested qosGPRSRequestedProfile;
+	qosGPRSRequestedProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosGPRSRequestedProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	TPckg< RPacketQoS::TQoSGPRSRequested > profilePckgGPRS(qosGPRSRequestedProfile);
+
+	TRequestStatus notifyProfileChangeStatus;
+	RPacketQoS::TQoSGPRSNegotiated profile;
+	TPckg<RPacketQoS::TQoSGPRSNegotiated> qosGPRSNegotiatedProfilePk(profile);
+	packetQoS.NotifyProfileChanged(notifyProfileChangeStatus, qosGPRSNegotiatedProfilePk);
+
+	TRequestStatus requestStatusGPRS;
+	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);
+	User::WaitForRequest(requestStatusGPRS);
+	ASSERT_EQUALS(KErrNone, requestStatusGPRS.Int());
+
+	//
+
+	RPacketContext::TContextConfigGPRS setConfigGPRSActiveNotifyConfigChanged;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRSNotifyConfigChanged(setConfigGPRSActiveNotifyConfigChanged);
+
+	TRequestStatus contextConfigStatus;
+	packetContext.NotifyConfigChanged(contextConfigStatus, pckgConfigGPRSNotifyConfigChanged);
+
+	TRequestStatus contextActivatingRequestStatus;
+	RPacketContext::TContextStatus contextStatus;
+	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);
+
+	TRequestStatus activateStatus;
+	packetContext.Activate(activateStatus);
+	User::WaitForRequest(activateStatus);
+	User::WaitForRequest(contextActivatingRequestStatus);
+	ASSERT_EQUALS(KErrNone, activateStatus.Int());
+	ASSERT_EQUALS(RPacketContext::EStatusActivating, contextStatus);
+
+	// Complete NotifyProfileChanged
+	User::WaitForRequest(notifyProfileChangeStatus);
+	ASSERT_EQUALS(KErrNone, notifyProfileChangeStatus.Int());
+
+	// Status change from RPacketContext::EStatusActivating to RPacketContext::EStatusActive
+	TRequestStatus contextActivateRequestStatus;
+	RPacketContext::TContextStatus contextActiveStatus;
+	packetContext.NotifyStatusChange(contextActivateRequestStatus, contextActiveStatus);
+
+	User::WaitForRequest(contextActivateRequestStatus);
+	ASSERT_EQUALS(KErrNone, contextActivateRequestStatus.Int());
+	ASSERT_EQUALS(RPacketContext::EStatusActive, contextActiveStatus);
+
+	// Prepare context configuration for GPRS
+	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv6;
+	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS2(setConfigGPRS);
+
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS2);
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());
+
+	TRequestStatus requestStatus;
+	packetContext.Deactivate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);
+
+	packetQoS.Close();
+	packetContext.Close();
+	packetService.Close();
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(5, this); // data, packetQoS, packetService, packetContext, this
+	}
+	
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0016
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextAddPacketFilter is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::AddPacketFilter()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0016L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesAddPacketFilter::KLtsyDispatchPacketServicesAddPacketFilterApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);
+		
+	RPacketContext packetContext;
+
+	// Open the primary context
+	TInfoName contextId;
+	TInt err = packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	ASSERT_EQUALS(KErrNone, err);
+	
+	TName qosName;
+	RPacketQoS packetQoS;
+	packetQoS.OpenNewQoS(packetContext, qosName);
+	CleanupClosePushL(packetQoS);
+
+	AssertMockLtsyStatusL();
+	
+	// Prepare context configuration for GPRS
+	RPacketContext::TContextConfigGPRS* setConfigGPRS = new (ELeave) RPacketContext::TContextConfigGPRS();
+	CleanupStack::PushL(setConfigGPRS);
+	setConfigGPRS->iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRS->iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRS->iPdpAddress.Copy(KPdpAddGPRS);
+	setConfigGPRS->iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	setConfigGPRS->iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRS->iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRS->iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRS->iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRS->iProtocolConfigOption.iId = KRequestID;
+	setConfigGPRS->iProtocolConfigOption.iMiscBuffer.Copy(KDummyMiscBuffer);
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(*setConfigGPRS);
+
+	// Create the PCO buffer
+	RPacketContext::TMiscProtocolBuffer pcoBuffer;
+	pcoBuffer.Zero();
+
+	// Generate a PCO buffer
+	PCOGeneratorL(setConfigGPRS->iProtocolConfigOption, pcoBuffer);
+	setConfigGPRS->iProtocolConfigOption.iId = KRequestID;
+
+	DriverInitialiseContextL();
+	
+	RPacketContext::TDataChannelV2 dataChannel;
+	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);
+	TRequestStatus initialiseContextStatus;
+
+	// Initialise primary context
+	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);
+	User::WaitForRequest(initialiseContextStatus);
+	
+	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iPort == KFirstAllocatedContextName);	
+	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId); // Now deprecated
+	
+	AssertMockLtsyStatusL();
+		
+	// Setting default GPRS context parameters. 
+	RPacketContext::TContextConfigGPRS expContextConfigGprs;
+	expContextConfigGprs.iAccessPointName = KDefaultAccessPoint;
+	expContextConfigGprs.iPdpType = KDefaultPdpType;
+
+	TMockLtsyData1<RPacketContext::TContextConfigGPRS> expLtsyGprsData(expContextConfigGprs);
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	expLtsyGprsData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams::KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId, data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams::KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId, KErrNone);
+	
+	RPacketContext::TContextConfigGPRS defaultGprsContextConfig;
+	defaultGprsContextConfig.iAccessPointName = KDefaultAccessPoint;
+	defaultGprsContextConfig.iPdpType = KDefaultPdpType;
+	TPckg<RPacketContext::TContextConfigGPRS> defaultContextGprsConfigPckg(defaultGprsContextConfig);
+	TRequestStatus setDefaultContextParamsStatus;
+	packetService.SetDefaultContextParams(setDefaultContextParamsStatus, defaultContextGprsConfigPckg);
+	User::WaitForRequest(setDefaultContextParamsStatus);
+
+    ASSERT_EQUALS(KErrNone, setDefaultContextParamsStatus.Int());
+    
+	AssertMockLtsyStatusL();
+	
+	DriverSetConfigContextL(contextId, setConfigGPRS->iAccessPointName, setConfigGPRS->iPdpType, setConfigGPRS->iPdpAddress, pcoBuffer);
+	
+	TRequestStatus setConfigStatus;
+	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);
+	User::WaitForRequest(setConfigStatus);
+	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());
+		
+	
+	//
+	// SetProfileParameters for GPRS Configurations
+	//
+	
+	RPacketQoS::TQoSGPRSRequested* qosExpectedRequestedGPRSProfile = new (ELeave) RPacketQoS::TQoSGPRSRequested();
+    qosExpectedRequestedGPRSProfile->iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile->iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosExpectedRequestedGPRSProfile->iReqDelay = RPacketQoS::EDelayClass1;
+	qosExpectedRequestedGPRSProfile->iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosExpectedRequestedGPRSProfile->iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;
+	qosExpectedRequestedGPRSProfile->iMinReliability = RPacketQoS::EReliabilityClass1;
+	qosExpectedRequestedGPRSProfile->iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile->iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosExpectedRequestedGPRSProfile->iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosExpectedRequestedGPRSProfile->iMinMeanThroughput = RPacketQoS::EMeanThroughput500;
+
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSData(contextId, *qosExpectedRequestedGPRSProfile);
+	data.Close();
+	packetSetConfigGPRSData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);
+
+	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextId);
+	callbackSetPdpGPRSContextNameData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);
+
+	RPacketQoS::TQoSGPRSRequested*  qosGPRSRequestedProfile = new (ELeave) RPacketQoS::TQoSGPRSRequested();
+	qosGPRSRequestedProfile->iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile->iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;
+	qosGPRSRequestedProfile->iReqDelay = RPacketQoS::EDelayClass1;
+	qosGPRSRequestedProfile->iMinDelay = RPacketQoS::EUnspecifiedDelayClass;
+	qosGPRSRequestedProfile->iReqReliability =  RPacketQoS::EUnspecifiedReliabilityClass;
+	qosGPRSRequestedProfile->iMinReliability = RPacketQoS::EReliabilityClass1;
+	qosGPRSRequestedProfile->iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;
+	qosGPRSRequestedProfile->iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput; 
+	qosGPRSRequestedProfile->iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;
+	qosGPRSRequestedProfile->iMinMeanThroughput = RPacketQoS::EMeanThroughput500;
+	TPckg< RPacketQoS::TQoSGPRSRequested > profilePckgGPRS(*qosGPRSRequestedProfile);
+	
+	TRequestStatus notifyProfileChangeStatus;
+	RPacketQoS::TQoSGPRSNegotiated profile;
+	TPckg<RPacketQoS::TQoSGPRSNegotiated> qosGPRSNegotiatedProfilePk(profile);
+	packetQoS.NotifyProfileChanged(notifyProfileChangeStatus, qosGPRSNegotiatedProfilePk);
+
+	TRequestStatus requestStatusGPRS;
+	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);
+	User::WaitForRequest(requestStatusGPRS);
+	ASSERT_EQUALS(KErrNone, requestStatusGPRS.Int());
+		
+	AssertMockLtsyStatusL();
+	
+	TRequestStatus contextConfigStatus;
+	RPacketContext::TContextConfigGPRS* setConfigGPRSActiveNotifyConfigChanged = new (ELeave) RPacketContext::TContextConfigGPRS();
+	CleanupStack::PushL(setConfigGPRSActiveNotifyConfigChanged);
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRSNotifyConfigChanged(*setConfigGPRSActiveNotifyConfigChanged);
+	packetContext.NotifyConfigChanged(contextConfigStatus, pckgConfigGPRSNotifyConfigChanged);
+	
+	TRequestStatus contextActivatingRequestStatus;
+	RPacketContext::TContextStatus contextStatus;
+	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);
+			
+	TMockLtsyData1<TInfoName> expectedActivateContextNameData(contextId);
+	data.Close();
+	expectedActivateContextNameData.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, data, KErrNone);
+				
+	TMockLtsyData3<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolType>
+		completedActivateContextNameData(contextId, setConfigGPRS->iAccessPointName, setConfigGPRS->iPdpType);
+	data.Close();
+	completedActivateContextNameData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, KErrNone, data);
+	
+	RPacketQoS::TQoSGPRSNegotiated completedProfile;
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSNegotiated>
+					expLtsyQosProfileChangedInd(contextId, completedProfile);
+	data.Close();
+	expLtsyQosProfileChangedInd.SerialiseL(data);
+	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyQosProfileChangedIndId, KErrNone, data);
+	
+	// Prepare context configuration for GPRS
+	RPacketContext::TContextConfigGPRS* setConfigGPRSActive  = new (ELeave) RPacketContext::TContextConfigGPRS();
+	setConfigGPRSActive->iAccessPointName.Copy(KPointNameGPRS);
+	setConfigGPRSActive->iPdpType = RPacketContext::EPdpTypeIPv4;
+	setConfigGPRSActive->iPdpCompression = 0;
+	setConfigGPRSActive->iPdpAddress.Copy(KPdpAddGPRSActive);	
+	setConfigGPRSActive->iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);
+	setConfigGPRSActive->iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	setConfigGPRSActive->iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	setConfigGPRSActive->iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	setConfigGPRSActive->iProtocolConfigOption.iId = KRequestID;
+
+	TMockLtsyData5<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolAddress, TUint, RPacketContext::TMiscProtocolBuffer>
+					expLtsyProfileChangedInd(contextId, setConfigGPRSActive->iAccessPointName,
+					setConfigGPRSActive->iPdpAddress, setConfigGPRSActive->iPdpCompression, pcoBuffer);
+	data.Close();
+	expLtsyProfileChangedInd.SerialiseL(data);
+	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyPdpContextConfigChangedIndId, KErrNone, data);
+	
+	// Activate primary context
+	TRequestStatus activateStatus;
+	packetContext.Activate(activateStatus);
+	User::WaitForRequest(activateStatus);
+	
+	// Complete NotifyProfileChanged
+	User::WaitForRequest(notifyProfileChangeStatus);
+	ASSERT_EQUALS(KErrNone, notifyProfileChangeStatus.Int());
+	
+	User::WaitForRequest(contextActivatingRequestStatus);
+	ASSERT_EQUALS(KErrNone, activateStatus.Int());
+	ASSERT_EQUALS(RPacketContext::EStatusActivating, contextStatus);
+	
+	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);
+	
+	User::WaitForRequest(contextActivatingRequestStatus);
+	ASSERT_EQUALS(RPacketContext::EStatusActive, contextStatus);
+
+	AssertMockLtsyStatusL();
+	
+	//Open Secondary Packet Context
+	TInfoName secondaryContextId;
+	RPacketContext secondaryContext;	
+	err = secondaryContext.OpenNewSecondaryContext(packetService, contextId, secondaryContextId);
+	CleanupClosePushL(secondaryContext);
+	ASSERT_EQUALS(KErrNone, err);
+	
+	AssertMockLtsyStatusL();
+				
+	DriverInitialiseContextL(contextId, secondaryContextId);
+
+	RPacketContext::TDataChannelV2* secondDataChannel = new (ELeave) RPacketContext::TDataChannelV2();
+	RPacketContext::TDataChannelV2Pckg secondDataChannelPk(*secondDataChannel);
+	TRequestStatus secondInitialiseContextStatus;
+	
+	// Initialise secondary context
+	secondaryContext.InitialiseContext(secondInitialiseContextStatus, secondDataChannelPk);
+	User::WaitForRequest(secondInitialiseContextStatus);	
+	ASSERT_EQUALS(KErrNone, secondInitialiseContextStatus.Int());
+	ASSERT_TRUE(dataChannel.iPort == KFirstAllocatedContextName); 	
+	ASSERT_TRUE(secondDataChannel->iChannelId == KSecondaryContextChannelId); // Now deprecated
+				
+	AssertMockLtsyStatusL();
+	
+	// Open QoS for secondaty context
+	RPacketQoS secondaryPacketQoS;
+	secondaryPacketQoS.OpenNewQoS(secondaryContext, secondaryContextId);
+	CleanupClosePushL(secondaryPacketQoS);
+	
+	RPacketQoS::TQoSGPRSRequested* qosExpectedRequestedGPRSProfileSecondaryContext = new (ELeave) RPacketQoS::TQoSGPRSRequested();	
+	qosExpectedRequestedGPRSProfileSecondaryContext->iMinMeanThroughput = RPacketQoS::EMeanThroughput500;
+	
+	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSDataSecondaryContext(secondaryContextId, *qosExpectedRequestedGPRSProfileSecondaryContext);
+	data.Close();
+	packetSetConfigGPRSDataSecondaryContext.SerialiseL(data);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);
+
+	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameDataSecondaryContext(secondaryContextId);
+	callbackSetPdpGPRSContextNameDataSecondaryContext.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);
+	
+	//Define qos params for secondaty context   
+	RPacketQoS::TQoSGPRSRequested* qosGPRSRequestedProfilesecondaryPacket = new (ELeave) RPacketQoS::TQoSGPRSRequested();
+	qosGPRSRequestedProfilesecondaryPacket->iMinMeanThroughput = RPacketQoS::EMeanThroughput500;
+	TPckg<RPacketQoS::TQoSGPRSRequested> qosGPRSRequestedProfilePk(*qosGPRSRequestedProfilesecondaryPacket);    
+	
+	//Set QoS Params GPRS for secondaty context
+	TRequestStatus setProfileParametersSt;
+	secondaryPacketQoS.SetProfileParameters(setProfileParametersSt, qosGPRSRequestedProfilePk);
+	User::WaitForRequest(setProfileParametersSt);
+	ASSERT_EQUALS(KErrNone, setProfileParametersSt.Int());
+	
+	AssertMockLtsyStatusL();
+		
+	// Configure packet filter  secondary context	    	    
+    RPacketContext::TPacketFilterV2* packetFilterV2 = new (ELeave) RPacketContext::TPacketFilterV2();
+    packetFilterV2->iId = 1;
+    packetFilterV2->iEvaluationPrecedenceIndex = 100;
+    packetFilterV2->iDestPortMax = 4001;
+    packetFilterV2->iDestPortMin = 4000;        
+    packetFilterV2->iIPSecSPI = 1;    
+    packetFilterV2->iProtocolNumberOrNextHeader = 0;
+    packetFilterV2->iSrcAddr[12] = 0;
+    memcpy(&(packetFilterV2->iSrcAddr[0]), "200.12.13.19", 12);
+    packetFilterV2->iSrcAddrSubnetMask[13] = 0;
+    memcpy(&(packetFilterV2->iSrcAddrSubnetMask[0]), "255.255.255.0", 13);    
+    packetFilterV2->iSrcPortMin = 5000;
+    packetFilterV2->iSrcPortMax = 5001;
+    packetFilterV2->iTOSorTrafficClass = 0;    
+    RPacketContext::TPacketFilterV2Pckg packetFilterV2Pckg(*packetFilterV2);
+    CArrayFixFlat<RPacketContext::TPacketFilterV2>* filterTemporaryArray = new ( ELeave ) CArrayFixFlat<RPacketContext::TPacketFilterV2>( 1 );
+    CleanupStack::PushL(filterTemporaryArray);
+    filterTemporaryArray->AppendL( *packetFilterV2 );
+	
+	TRequestStatus addPacketFilterStatus;
+
+	// Add filter to secondary context.
+    secondaryContext.AddPacketFilter(addPacketFilterStatus, packetFilterV2Pckg);	    	    
+	User::WaitForRequest(addPacketFilterStatus);
+	ASSERT_EQUALS(KErrNotSupported, addPacketFilterStatus.Int());
+
+	TRequestStatus requestStatus;	
+	iMockLTSY.NotifyTerminated(requestStatus);
+	
+	DriverDeleteContextL(secondaryContextId);
+	DriverDeleteContextL(contextId);
+
+	secondaryPacketQoS.Close();
+	packetQoS.Close();
+				
+	secondaryContext.Close();
+	packetContext.Close();
+	packetService.Close();
+
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(), KErrNone);
+	
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(10, this);   // setSecondaryConfigGPRSActiveNotifyConfigChanged, secondarySetConfigGPRSActive, secondarysetConfigGPRSActiveNotifyConfigChanged, 
+											//filterTemporaryArray, secondPacketContext, setConfigGPRSActiveNotifyConfigChanged, data, setConfigGPRS, packetQoS, packetService, packetContext, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0018
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketInitProxiesIPC is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::Open() 
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0018L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+    RPacketService packetService;  
+	TRequestStatus requestStatus;
+	iMockLTSY.NotifyTerminated(requestStatus);
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId);	
+
+	TUint staticCapabilities        
+		= RPacketService::KCapsSuspendSupported
+		| RPacketService::KCapsNetworkAvailabilitySupported
+		| RPacketService::KCapsSetDefaultContextSupported
+		| RPacketService::KCapsChangeAttachModeSupported
+		| RPacketService::KCapsGetDataTransferredSupported
+		| RPacketService::KCapsPreferredBearerSupported
+		| RPacketService::KCapsPdpDataCompSupported
+		| RPacketService::KCapsPdpHeaderCompSupported
+		| RPacketService::KCapsMSClassSupported
+		| RPacketService::KCapsNotifyMSClassSupported;
+	
+	TMockLtsyData1<TUint> packetServiceStaticCapabilities(staticCapabilities);
+	packetServiceStaticCapabilities.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId, KErrNone, data);
+	data.Close();
+	
+  	TInt maxNoMonitoredServiceLists = 32;
+	TMockLtsyData1<TInt> maxNoMonitoredServiceListsData(maxNoMonitoredServiceLists);
+	maxNoMonitoredServiceListsData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId, KErrNone, data);
+	data.Close();
+	
+	TInt maxNoActiveServices = 64;
+	TMockLtsyData1<TInt> maxNoActiveServicesData(maxNoActiveServices);
+	maxNoActiveServicesData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId, KErrNone, data);
+
+	CleanupClosePushL(packetService);
+
+	ASSERT_EQUALS(packetService.Open(iPhone), KErrNone);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(), KErrNone);
+
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // packetService, data, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0019
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketGetStaticCaps is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::GetStaticCaps()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0019L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+
+    RPacketService packetService;       
+	TRequestStatus requestStatus;
+	iMockLTSY.NotifyTerminated(requestStatus);
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId);	
+
+	TBool resumed = EFalse; // Flag indicating whether packet service has been resumed from suspended state.
+	RPacketService::TStatus packetServiceStatus = RPacketService::EStatusUnattached;
+	TMockLtsyData2<RPacketService::TStatus, TBool> packetServiceStatusData(packetServiceStatus, resumed);
+	packetServiceStatusData.SerialiseL(data);
+  	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId, KErrNone, data);
+  	data.Close();
+  	
+  	TInt maxNoMonitoredServiceLists = 32;
+	TMockLtsyData1<TInt> maxNoMonitoredServiceListsData(maxNoMonitoredServiceLists);
+	maxNoMonitoredServiceListsData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId, KErrNone, data);
+	data.Close();
+	
+	TInt maxNoActiveServices = 64;
+	TMockLtsyData1<TInt> maxNoActiveServicesData(maxNoActiveServices);
+	maxNoActiveServicesData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId, KErrNone, data);
+
+	CleanupClosePushL(packetService);
+	ASSERT_EQUALS(packetService.Open(iPhone),KErrNone);
+	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(),KErrNone);
+	AssertMockLtsyStatusL();
+	
+	//check the capabilities
+	TUint caps = 0;
+	TInt ret = packetService.GetStaticCaps(caps,RPacketContext::EPdpTypeIPv4); // still returns KErrNone 
+	ASSERT_EQUALS(ret, KErrNone); 
+	
+	AssertMockLtsyStatusL();	
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // packetService, data, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0020
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketEnumerateMbmsMonitorServiceList is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::EnumerateMbmsMonitorServiceList()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0020L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+
+    RPacketService packetService;       
+	TRequestStatus requestStatus;
+	iMockLTSY.NotifyTerminated(requestStatus);
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId);	
+
+	TUint staticCapabilities        
+		= RPacketService::KCapsSuspendSupported
+		| RPacketService::KCapsNetworkAvailabilitySupported
+		| RPacketService::KCapsSetDefaultContextSupported
+		| RPacketService::KCapsChangeAttachModeSupported
+		| RPacketService::KCapsGetDataTransferredSupported
+		| RPacketService::KCapsPreferredBearerSupported
+		| RPacketService::KCapsPdpDataCompSupported
+		| RPacketService::KCapsPdpHeaderCompSupported
+		| RPacketService::KCapsMSClassSupported
+		| RPacketService::KCapsNotifyMSClassSupported;
+	
+	TMockLtsyData1<TUint> packetServiceStaticCapabilities(staticCapabilities);
+	packetServiceStaticCapabilities.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId, KErrNone, data);
+	data.Close();
+	
+	TBool resumed = EFalse; // Flag indicating whether packet service has been resumed from suspended state.
+	RPacketService::TStatus packetServiceStatus = RPacketService::EStatusUnattached;
+	TMockLtsyData2<RPacketService::TStatus, TBool> packetServiceStatusData(packetServiceStatus, resumed);
+	packetServiceStatusData.SerialiseL(data);
+  	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId, KErrNone, data);
+  	data.Close();
+	
+	TInt maxNoActiveServices = 64;
+	TMockLtsyData1<TInt> maxNoActiveServicesData(maxNoActiveServices);
+	maxNoActiveServicesData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId, KErrNone, data);
+
+	CleanupClosePushL(packetService);
+	ASSERT_EQUALS(packetService.Open(iPhone),KErrNone);
+	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(),KErrNone);
+	AssertMockLtsyStatusL();
+	
+	//check the max no monitored service lists
+	TInt count = 0;
+	TInt maxAllowed = 0;
+	packetService.EnumerateMbmsMonitorServiceList(requestStatus,count,maxAllowed);
+	User::WaitForRequest(requestStatus); // still KErrNone
+	ASSERT_EQUALS(requestStatus.Int(), KErrNone);
+	
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // packetService, data, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0021
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketEnumerateMbmsActiveServiceList is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::EnumerateMbmsActiveServiceList()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0021L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+
+    RPacketService packetService;      
+	TRequestStatus requestStatus;
+	iMockLTSY.NotifyTerminated(requestStatus);
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId);
+	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId);
+
+	TUint staticCapabilities        
+		= RPacketService::KCapsSuspendSupported
+		| RPacketService::KCapsNetworkAvailabilitySupported
+		| RPacketService::KCapsSetDefaultContextSupported
+		| RPacketService::KCapsChangeAttachModeSupported
+		| RPacketService::KCapsGetDataTransferredSupported
+		| RPacketService::KCapsPreferredBearerSupported
+		| RPacketService::KCapsPdpDataCompSupported
+		| RPacketService::KCapsPdpHeaderCompSupported
+		| RPacketService::KCapsMSClassSupported
+		| RPacketService::KCapsNotifyMSClassSupported;
+	
+	TMockLtsyData1<TUint> packetServiceStaticCapabilities(staticCapabilities);
+	packetServiceStaticCapabilities.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId, KErrNone, data);
+	data.Close();
+	
+	TBool resumed = EFalse; // Flag indicating whether packet service has been resumed from suspended state.
+	RPacketService::TStatus packetServiceStatus = RPacketService::EStatusUnattached;
+	TMockLtsyData2<RPacketService::TStatus, TBool> packetServiceStatusData(packetServiceStatus, resumed);
+	packetServiceStatusData.SerialiseL(data);
+  	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId, KErrNone, data);
+  	data.Close();
+  	
+  	TInt maxNoMonitoredServiceLists = 32;
+	TMockLtsyData1<TInt> maxNoMonitoredServiceListsData(maxNoMonitoredServiceLists);
+	maxNoMonitoredServiceListsData.SerialiseL(data);
+	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId, KErrNone, data);
+	data.Close();
+
+	CleanupClosePushL(packetService);
+	ASSERT_EQUALS(packetService.Open(iPhone),KErrNone);
+	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(),KErrNone);
+	AssertMockLtsyStatusL();
+
+	//check the max no monitored service lists
+	TInt count = 0;
+	TInt maxAllowed = 0;
+
+	packetService.EnumerateMbmsActiveServiceList(requestStatus, count, maxAllowed); 
+	User::WaitForRequest(requestStatus); // still KErrNone
+	ASSERT_EQUALS(requestStatus.Int(),KErrNone);
+	
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // packetService, data, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0022
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if ECtsyPacketMbmsInitialiseContextReq is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::InitialiseContext()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0022L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesInitialiseMbmsContext::KLtsyDispatchPacketServicesInitialiseMbmsContextApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+	
+	TInfoName contextName;
+	RPacketMbmsContext packetContext;
+	
+	packetContext.OpenNewContext(packetService, contextName);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus requestStatus;
+	RPacketContext::TDataChannelV2 dataChannel1;
+	RPacketContext::TDataChannelV2Pckg dataChannelPckg1(dataChannel1);
+
+	packetContext.InitialiseContext(requestStatus, dataChannelPckg1);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);
+
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0023
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketGetMbmsNetworkServiceStatus is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::GetMbmsNetworkServiceStatus()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0023L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus::KLtsyDispatchPacketServicesGetMbmsNetworkServiceStatusApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+    
+	TRequestStatus requestStatus;
+    TMbmsNetworkServiceStatus mbmsNetworkServiceStatus;
+    
+	packetService.GetMbmsNetworkServiceStatus(requestStatus, ETrue, mbmsNetworkServiceStatus);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);
+	
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(2, this); // packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0024
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketUpdateMbmsMonitorServiceList is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketService::UpdateMbmsMonitorServiceListL()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0024L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList::KLtsyDispatchPacketServicesUpdateMbmsMonitorServiceListApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+    
+	TRequestStatus requestStatus;
+    CPcktMbmsMonitoredServiceList* multipleEntries = CPcktMbmsMonitoredServiceList ::NewL();
+	CleanupStack::PushL(multipleEntries);
+	RPacketService::TMbmsServiceAvailabilityV1 entry1, entry2;
+	TInt MBMS_MONITORSERVICECOUNTMULTIPLE = 3;
+	
+	for(TInt i=0;i < MBMS_MONITORSERVICECOUNTMULTIPLE ;i++)
+		{
+		entry1.iTmgi.SetServiceId(i); 
+		entry1.iTmgi.SetMCC(i);
+		entry1.iTmgi.SetMNC(i);
+		entry1.iMbmsServiceMode = KBroadcast;
+		entry1.iMbmsAccessBearer = E2GBearer;
+		entry1.iMbmsAvailabilityStatus = EMbmsUnavailable;
+		multipleEntries->AddEntryL( entry1 );
+		}
+	
+	packetService.UpdateMbmsMonitorServiceListL(requestStatus, EAddEntries, multipleEntries);	
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+	
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // multipleEntries, packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0025
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test returned value if EPacketContextUpdateMbmsSessionList is not supported by LTSY
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketMbmsContext::UpdateMbmsSessionList()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyPacketServicesFUNegative::TestUnit0025L()
+	{
+	TConfig config;
+	config.SetSupportedValue(MLtsyDispatchPacketServicesUpdateMbmsSessionList::KLtsyDispatchPacketServicesUpdateMbmsSessionListApiId, EFalse);
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup, this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);
+	
+	TInfoName contextId;	
+	RPacketMbmsContext mbmsContext;	
+	mbmsContext.OpenNewContext(packetService, contextId);	 
+	CleanupClosePushL( mbmsContext );	
+    
+	TRequestStatus requestStatus;
+    TMbmsSessionId session = 0;  
+    
+    mbmsContext.UpdateMbmsSessionList(requestStatus, EAddEntries, session);    
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);
+	
+	AssertMockLtsyStatusL();
+	config.Reset();
+	CleanupStack::PopAndDestroy(3, this); // mbmsContext, packetService, this	
+	}