telephonyserverplugins/common_tsy/test/component/src/cctsypacketcontextfu.cpp
changeset 0 3553901f7fa8
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/component/src/cctsypacketcontextfu.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,6562 @@
+// Copyright (c) 2007-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:
+// The TEFUnit test suite for PacketContext in the Common TSY.
+// 
+//
+
+/**
+ @file 
+*/
+
+#include "cctsypacketcontextfu.h"
+#include <etel.h>
+#include <etelmm.h>
+#include <et_clsvr.h>
+#include <ctsy/mmtsy_names.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include "tmockltsydata.h"
+#include <ctsy/serviceapi/gsmerror.h>
+
+#include <pcktcs.h>
+#include "CMmCommonStaticUtility.h"
+#include <ctsy/serviceapi/mmtsy_defaults.h>
+
+
+
+CTestSuite* CCTsyPacketContextFU::CreateSuiteL(const TDesC& aName)
+	{
+	SUB_SUITE;
+
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyStatusChange0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyStatusChange0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyStatusChange0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyStatusChange0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyStatusChange0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDeactivate0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDeactivate0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDeactivate0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDeactivate0004L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDeactivate0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDnsInfo0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDnsInfo0002L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDnsInfo0003L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDnsInfo0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDnsInfo0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestLoanCommPort0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestLoanCommPort0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestLoanCommPort0003L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestLoanCommPort0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestLoanCommPort0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetProfileName0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetProfileName0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetProfileName0003L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetProfileName0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetProfileName0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestRecoverCommPort0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestRecoverCommPort0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestRecoverCommPort0003L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestRecoverCommPort0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestRecoverCommPort0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetLastErrorCause0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetLastErrorCause0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetLastErrorCause0003L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetLastErrorCause0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetLastErrorCause0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestInitialiseContext0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestInitialiseContext0002L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestInitialiseContext0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestInitialiseContext0004L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestInitialiseContext0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionSpeed0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionSpeed0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionSpeed0003L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionSpeed0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionSpeed0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestModifyActiveContext0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestModifyActiveContext0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestModifyActiveContext0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestModifyActiveContext0004L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestModifyActiveContext0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConfigChanged0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConfigChanged0001bL);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConfigChanged0001cL);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConfigChanged0002L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConfigChanged0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConfigChanged0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConfigChanged0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyDataTransferred0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyDataTransferred0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyDataTransferred0003L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyDataTransferred0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyDataTransferred0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestEnumeratePacketFilters0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestEnumeratePacketFilters0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestEnumeratePacketFilters0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestEnumeratePacketFilters0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestEnumeratePacketFilters0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDataVolumeTransferred0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDataVolumeTransferred0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDataVolumeTransferred0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDataVolumeTransferred0004L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetDataVolumeTransferred0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionSpeedChange0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionSpeedChange0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionSpeedChange0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionSpeedChange0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionSpeedChange0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDelete0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDelete0002L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDelete0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDelete0004L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestDelete0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestActivate0001L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestActivate0001bL);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestActivate0002L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestActivate0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestActivate0004L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestActivate0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConfig0001L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConfig0002L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConfig0003L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConfig0004L);
+//	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConfig0005L);
+	ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetStatus0001L);
+    //ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetStatus0002L);
+    //ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetStatus0003L);
+    //ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetStatus0004L);
+    //ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetStatus0005L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestSetConfig0001L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestSetConfig0002L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestSetConfig0003L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestSetConfig0004L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestSetConfig0005L);    
+#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionInfo0001L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionInfo0002L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestGetConnectionInfo0004L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionInfoChange0001L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionInfoChange0002L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestNotifyConnectionInfoChange0004L);
+#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenNewSecondaryContext0001L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenNewSecondaryContext0001bL);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenNewSecondaryContext0003L);   
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenNewSecondaryContext0003bL);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenNewSecondaryContext0003cL);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenNewContext0001L);
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenNewContext0003L);    
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenExistingContext0001L);    
+    ADD_TEST_STEP_ISO_CPP(CCTsyPacketContextFU, TestOpenExistingContext0003L);   
+
+	END_SUITE;
+	}
+
+
+//
+// Actual test cases
+//
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNSC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyStatusChange
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::NotifyStatusChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyStatusChange0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	// data for NotifyStatusChange
+	TRequestStatus	requestStatus;
+	RPacketContext::TContextStatus  contextStatus; 
+
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::NotifyStatusChange when result is not cached.
+ 	//------------------------------------------------------------------------- 	
+ 	//data for ComleteL    
+ 	TContextMisc  completeMisc;
+    completeMisc.iStatus = RPacketContext::EStatusInactive;
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc);
+	ltsyData.SerialiseL(data);	
+	//send request
+	packetContext.NotifyStatusChange(requestStatus, contextStatus);	
+	//send completion
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	
+	// wait for NotifyStatusChange
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(completeMisc.iStatus, contextStatus);	
+	AssertMockLtsyStatusL();
+	
+	//-------------------------------------------------------------------------
+	// Test when rejection cause is used
+ 	//------------------------------------------------------------------------- 	
+ 	//data for ComleteL     
+ 	_LIT(KSomeCause, "1");
+ 	completeMisc.iRejectionCause.Copy(KSomeCause);
+    completeMisc.iStatus = RPacketContext::EStatusActive;//EStatusInactive;
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData2(contextId, completeMisc);
+	data.Close();
+	ltsyData2.SerialiseL(data);	
+	//send request
+	packetContext.NotifyStatusChange(requestStatus, contextStatus);
+	
+	//send completion
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrGeneral, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	
+	// wait for NotifyStatusChange
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(completeMisc.iStatus, contextStatus);
+	AssertMockLtsyStatusL();
+ 
+ 	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::NotifyStatusChange
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+ 	//data for ComleteL    
+    completeMisc.iStatus = RPacketContext::EStatusInactive;//EStatusActive;
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData1(contextId, completeMisc);
+	data.Close();
+	ltsyData1.SerialiseL(data);	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);	
+	//send completion
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(2, this); // data, this
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNSC-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::NotifyStatusChange
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::NotifyStatusChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyStatusChange0002L()
+	{
+
+// This test should test cancellation of NotifyStatusChange
+// If this API does not have a cancel, the test step should be completely removed.
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	// data for NotifyStatusChange
+	TRequestStatus	requestStatus;
+	RPacketContext::TContextStatus  contextStatus; 
+
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::NotifyStatusChange
+ 	//------------------------------------------------------------------------- 	
+	//data for ComleteL    
+ 	TContextMisc  completeMisc;
+    completeMisc.iStatus = RPacketContext::EStatusInactive;
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc);
+	ltsyData.SerialiseL(data);	
+	//send request
+	packetContext.NotifyStatusChange(requestStatus, contextStatus);	
+	// send canceling...
+	packetContext.CancelAsyncRequest(EPacketContextNotifyStatusChange);
+	
+	//send completion
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	
+	// wait for NotifyStatusChange
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+	
+	// Wait for completion of iMockLTSY.NotifyTerminated
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(2); // data, this
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNSC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::NotifyStatusChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::NotifyStatusChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyStatusChange0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::NotifyStatusChange
+ 	//-------------------------------------------------------------------------
+
+	// If this API is flow controlled by Etel or if this API is
+	// synchronous, remove this test completely.
+
+	// To write this test:
+	// If this API has parameters which have different versions, then each
+	// client in this test should use a different version of parameter.
+	// Otherwise, they should use the same version.
+	// All versions of parameters should be used. i.e. If there are three
+	// versions of a parameter, there should be three clients, one using
+	// each one. If the parameter does not have different versions, use
+	// two clients each using the same version.
+	
+	//data for ComleteL  for first context
+ 	TContextMisc  completeMisc;
+    completeMisc.iStatus = RPacketContext::EStatusInactive;
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc);
+	ltsyData.SerialiseL(data);	
+	
+	//data for ComleteL  for second context
+ 	TContextMisc  completeMisc2;
+    completeMisc2.iStatus = RPacketContext::EStatusSuspended;
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData2(contextId2, completeMisc2);
+	ltsyData2.SerialiseL(data2);	
+		
+	// initialize data for first context's NotifyStatusChange 
+	TRequestStatus	requestStatus; 
+	RPacketContext::TContextStatus  contextStatus = RPacketContext::EStatusDeleted; 
+	
+	// initialize data for second context's NotifyStatusChange 
+	TRequestStatus	requestStatus2;
+	RPacketContext::TContextStatus  contextStatus2 = RPacketContext::EStatusDeleted; 	
+		
+	//send first request
+	packetContext.NotifyStatusChange(requestStatus, contextStatus);	
+	
+	//send second request
+	packetContext2.NotifyStatusChange(requestStatus2, contextStatus2);	
+	
+	//send completion for first comtext
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data);	
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+		
+	// wait for first context NotifyStatusChange
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(completeMisc.iStatus, contextStatus);	
+	// check that contextStatus2 ((of the second context)) isn't changed
+	ASSERT_EQUALS(RPacketContext::EStatusDeleted, contextStatus2);	
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	//send completion for second comtext
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data2);	
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+		
+	// wait for second context NotifyStatusChange
+	User::WaitForRequest(requestStatus2);
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+	ASSERT_EQUALS(completeMisc2.iStatus, contextStatus2);	
+	// check that contextStatus (of the first context) isn't changed
+	ASSERT_EQUALS(completeMisc.iStatus, contextStatus);
+	
+	AssertMockLtsyStatusL();
+	
+	// Done !
+	CleanupStack::PopAndDestroy(4);// packetContext2, packetContext, packetService2, packetService
+	CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, data, data2, this
+
+	}
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCD-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Deactivate
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Deactivate
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestDeactivate0001L()
+	{
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);	
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;		
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A: failure to dispatch request to LTSY
+ 	//------------------------------------------------------------------------- 	
+ 	TMockLtsyData1 <TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+ 	iMockLTSY.ExpectL(EPacketContextDeactivate, data, KErrNotFound);		
+ 	
+ 	TRequestStatus requestStatus;
+	packetContext.Deactivate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotFound, requestStatus.Int());
+
+	//-------------------------------------------------------------------------
+	// TEST B: failure on completion of pending request from LTSY->CTSY
+ 	//-------------------------------------------------------------------------  	
+    iMockLTSY.ExpectL(EPacketContextDeactivate, data);
+	iMockLTSY.CompleteL(EPacketContextDeactivate, KErrGeneral, data);
+	
+	packetContext.Deactivate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::Deactivate when result is not cached.
+ 	//-------------------------------------------------------------------------	
+	iMockLTSY.ExpectL(EPacketContextDeactivate, data);
+	iMockLTSY.CompleteL(EPacketContextDeactivate, KErrNone, data);
+	
+	packetContext.Deactivate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+  	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::Deactivate
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);	
+	iMockLTSY.CompleteL(EPacketContextDeactivate, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(2, this); // data, this
+}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCD-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::Deactivate
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::Deactivate
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestDeactivate0002L()
+	{
+
+// This test should test cancellation of Deactivate
+// If this API does not have a cancel, the test step should be completely removed.
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();	
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::Deactivate
+ 	//-------------------------------------------------------------------------
+ 	TRequestStatus	requestStatus;
+ 	TMockLtsyData1 <TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+	
+	iMockLTSY.ExpectL(EPacketContextDeactivate, data);
+	iMockLTSY.CompleteL(EPacketContextDeactivate, KErrNone, data, 10);
+	
+	packetContext.Deactivate(requestStatus);
+	packetContext.CancelAsyncRequest(EPacketContextDeactivate);
+	User::WaitForRequest(requestStatus);
+	
+	// CTSY has started a request and it is not possible to then cancel 
+    // this request. The best thing for the TSY to do in this case is to
+    // proceed as though the Cancel never happened.    
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(2); // data, this	
+	}
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCD-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::Deactivate
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::Deactivate
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestDeactivate0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::Deactivate
+ 	//-------------------------------------------------------------------------
+	
+	TRequestStatus	requestStatus;
+ 	TMockLtsyData1 <TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+	
+	// data for second context
+	TRequestStatus	requestStatus2;
+ 	TMockLtsyData1 <TInfoName > ltsyData2(contextId2);
+	ltsyData2.SerialiseL(data2);
+	
+	iMockLTSY.ExpectL(EPacketContextDeactivate, data);
+	iMockLTSY.CompleteL(EPacketContextDeactivate, KErrNone, data, 10);
+	
+	iMockLTSY.ExpectL(EPacketContextDeactivate, data2);
+	iMockLTSY.CompleteL(EPacketContextDeactivate, KErrNone, data2, 10);
+	
+	packetContext.Deactivate(requestStatus);
+	packetContext2.Deactivate(requestStatus2);
+	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	User::WaitForRequest(requestStatus2);
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+	CleanupStack::PopAndDestroy(4); // packetContext, packetService, packetContext2, packetService2
+	CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, data, data2, this
+
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCD-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Deactivate with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Deactivate and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestDeactivate0005L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test timeout of RPacketContext::Deactivate
+ 	//-------------------------------------------------------------------------
+	TRequestStatus	requestStatus;
+	TMockLtsyData1 <TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+
+	iMockLTSY.ExpectL(EPacketContextDeactivate, data);	
+	packetContext.Deactivate(requestStatus);
+	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(2, this); // data, this
+
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGDI-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetDnsInfo
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetDnsInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetDnsInfo0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+
+	 //------------------------------------------------------------------------
+	// TEST D: RPacketContext::GetDnsInfo again, this time CTSY
+	// will get result from the cache.
+ 	//-------------------------------------------------------------------------
+	TRequestStatus	requestStatus;
+	RPacketContext::TDnsInfoV2  dnsInfo;
+	
+	// init dnsInfo with same data, in order to check that it will be changed
+	_LIT(Kdummy, "Something");
+	dnsInfo.iPrimaryDns.Copy(Kdummy);
+	dnsInfo.iSecondaryDns.Copy(Kdummy);	
+	TPckg<RPacketContext::TDnsInfoV2> pckgDnsInfo(dnsInfo);	
+	
+	// call API itself
+	packetContext.GetDnsInfo(requestStatus, pckgDnsInfo);
+	
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	TBuf8<50> null50;
+	ASSERT_EQUALS(null50, dnsInfo.iPrimaryDns);
+	ASSERT_EQUALS(null50, dnsInfo.iSecondaryDns);
+		
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this	
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGDI-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetDnsInfo with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetDnsInfo with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetDnsInfo0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test passing wrong version of parameters to
+	// RPacketContext::GetDnsInfo
+ 	//-------------------------------------------------------------------------
+	TRequestStatus	requestStatus;
+	TInt  wrongDnsInfo;
+	TPckg<TInt> pckgDnsInfo(wrongDnsInfo);	
+	
+	packetContext.GetDnsInfo(requestStatus, pckgDnsInfo);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrArgument, requestStatus.Int());
+	
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCLCP-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::LoanCommPort
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::LoanCommPort
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestLoanCommPort0001L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	//-------------------------------------------------------------------------
+	// Test that this function isn't supported
+ 	//-------------------------------------------------------------------------
+	TRequestStatus	 requestStatus;
+	RCall::TCommPort dataPort;
+	packetContext.LoanCommPort(requestStatus, dataPort);
+	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGPN-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetProfileName
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetProfileName
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetProfileName0001L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+	
+	//-------------------------------------------------------------------------
+	//  check that no profile has been defined
+ 	//-------------------------------------------------------------------------
+	TName qosProfile;
+	TName null;
+	TInt status = packetContext.GetProfileName(qosProfile);
+	ASSERT_EQUALS(KErrNone, status);
+	// check that no profile has been defined
+	ASSERT_EQUALS(null, qosProfile);
+	
+	//-------------------------------------------------------------------------
+	// Get Name of existing QoS
+ 	//-------------------------------------------------------------------------
+	// create New QoS
+	RPacketQoS packetQoS;
+	TName qosName;
+	packetQoS.OpenNewQoS(packetContext, qosName);
+	CleanupClosePushL(packetQoS);
+	
+	status = packetContext.GetProfileName(qosProfile);
+	ASSERT_EQUALS(KErrNone, status);
+	ASSERT_EQUALS(qosName, qosProfile);
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4, this); //packetQoS, packetService, packetContext, this	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCRCP-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::RecoverCommPort
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::RecoverCommPort
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestRecoverCommPort0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+	
+	//-------------------------------------------------------------------------
+	// Test that this function isn't supported
+ 	//-------------------------------------------------------------------------
+	TRequestStatus	 requestStatus;
+	packetContext.RecoverCommPort(requestStatus);
+	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this
+	
+	}
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGLEC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetLastErrorCause
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetLastErrorCause
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetLastErrorCause0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	
+	//-------------------------------------------------------------------------
+	// Check that there is no error on begin
+ 	//-------------------------------------------------------------------------
+	TInt error;
+	TInt status = packetContext.GetLastErrorCause(error);
+	ASSERT_EQUALS(KErrNone, status);
+	ASSERT_EQUALS(KErrNone, error);
+
+	
+ 	//-------------------------------------------------------------------------
+	// Emulate some error
+ 	//-------------------------------------------------------------------------
+ 		
+	// -------Set context in to Activating state -------------------------------
+	TContextMisc  completeMisc;
+    completeMisc.iStatus = RPacketContext::EStatusActivating;    
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData1(contextId, completeMisc);
+	ltsyData1.SerialiseL(data);	
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	//send completion
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	
+	// ------- Emulate an error  -------------------------------
+    completeMisc.iStatus = RPacketContext::EStatusActive;    
+ 	TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc);
+	data.Close();
+	ltsyData.SerialiseL(data);		
+
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	//send completion
+	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrGeneral, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	
+	// Get the error
+	status = packetContext.GetLastErrorCause(error);
+	ASSERT_EQUALS(KErrNone, status);
+	ASSERT_EQUALS(KErrGeneral, error);
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4, this); // packetContext, packetService, data, this
+		
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCIC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::InitialiseContext
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::InitialiseContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestInitialiseContext0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+		
+ 	//-------------------------------------------------------------------------
+	// TEST A: failure to dispatch request to LTSY
+ 	//-------------------------------------------------------------------------
+ 	TInfoName hostCidName;
+    TMockLtsyData2< TInfoName, TInfoName > ltsyExpect(contextId, hostCidName);
+	ltsyExpect.SerialiseL(expectData);
+ 	
+ 	// data for initialisation of the context 
+	TRequestStatus requestStatus;
+	RPacketContext::TDataChannelV2 dataCh;
+	TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh);
+	
+	iMockLTSY.ExpectL(EPacketContextInitialiseContext,expectData, KErrNotSupported);
+	//initialisation of the context
+	packetContext.InitialiseContext(requestStatus, pckgInit);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	
+
+	//-------------------------------------------------------------------------
+	// TEST B: failure on completion of pending request from LTSY->CTSY
+ 	//-------------------------------------------------------------------------	
+	iMockLTSY.ExpectL(EPacketContextInitialiseContext, expectData);
+	TMockLtsyData1< TInfoName > ltsyData(contextId);
+	data.Close();
+	ltsyData.SerialiseL(data);	
+	iMockLTSY.CompleteL(EPacketContextInitialiseContext, KErrGeneral, data);
+	
+	//initialisation of the context
+	packetContext.InitialiseContext(requestStatus, pckgInit);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+	AssertMockLtsyStatusL();
+
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::InitialiseContext when result is not cached.
+ 	//-------------------------------------------------------------------------
+	
+	iMockLTSY.ExpectL(EPacketContextInitialiseContext, expectData);
+	iMockLTSY.CompleteL(EPacketContextInitialiseContext, KErrNone, data);
+	
+	//initialisation of the context
+	packetContext.InitialiseContext(requestStatus, pckgInit);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	RPacketContext::TDataChannelV2 retDataCh = pckgInit();
+    ASSERT_FALSE(retDataCh.iChannelId.Compare(contextId));
+  	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::InitialiseContext
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+	TRequestStatus mockLtsyStatus;
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	iMockLTSY.CompleteL(EPacketContextInitialiseContext, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(5, this); // expectData, data, this, packetService, packetContext	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCIC-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::InitialiseContext
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::InitialiseContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestInitialiseContext0002L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::InitialiseContext
+ 	//-------------------------------------------------------------------------
+ 	TInfoName hostCidName;
+    TMockLtsyData2< TInfoName, TInfoName > ltsyExpect(contextId, hostCidName);
+	ltsyExpect.SerialiseL(expectData);
+ 	
+ 	// data for initialisation of the context 
+	TRequestStatus requestStatus;
+	RPacketContext::TDataChannelV2 dataCh;
+	TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh);
+	
+	TMockLtsyData1< TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+	
+	iMockLTSY.ExpectL(EPacketContextInitialiseContext, expectData);	
+	iMockLTSY.CompleteL(EPacketContextInitialiseContext, KErrNone, data, 10);
+	
+	//initialisation of the context
+	packetContext.InitialiseContext(requestStatus, pckgInit);	
+	//cancel reguest
+	packetContext.CancelAsyncRequest(EPacketContextInitialiseContext);
+	
+	User::WaitForRequest(requestStatus);	
+	// CTSY has started a request and it is not possible to then cancel 
+    // this request. The best thing for the TSY to do in this case is to
+    // proceed as though the Cancel never happened.  
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	 	
+
+	// Wait for completion of iMockLTSY.NotifyTerminated
+	User::WaitForRequest(mockLtsyStatus);
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(3); // expectData, data, this
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCIC-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::InitialiseContext with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::InitialiseContext with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestInitialiseContext0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test passing wrong version of parameters to
+	// RPacketContext::InitialiseContext
+ 	//-------------------------------------------------------------------------
+
+	// data for initialisation of the context 
+	TRequestStatus requestStatus;
+	RCall::TCommPort dataCh; // old version of parameter
+	TPckg<RCall::TCommPort> pckgInit(dataCh);
+	
+	//initialisation of the context
+	packetContext.InitialiseContext(requestStatus, pckgInit);	
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrArgument, requestStatus.Int());
+	AssertMockLtsyStatusL();	 	
+
+	CleanupStack::PopAndDestroy(3, this); 
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCIC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::InitialiseContext
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::InitialiseContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestInitialiseContext0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RBuf8 expectData2;
+	CleanupClosePushL(expectData2);
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService, contextId2);
+	CleanupClosePushL(packetContext2);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::InitialiseContext
+ 	//-------------------------------------------------------------------------
+
+	// If this API is flow controlled by Etel or if this API is
+	// synchronous, remove this test completely.
+
+	// To write this test:
+	// If this API has parameters which have different versions, then each
+	// client in this test should use a different version of parameter.
+	// Otherwise, they should use the same version.
+	// All versions of parameters should be used. i.e. If there are three
+	// versions of a parameter, there should be three clients, one using
+	// each one. If the parameter does not have different versions, use
+	// two clients each using the same version.
+	
+	// for the first request
+	TInfoName hostCidName;
+    TMockLtsyData2< TInfoName, TInfoName > ltsyExpect(contextId, hostCidName);
+	ltsyExpect.SerialiseL(expectData);
+	
+	TRequestStatus requestStatus;
+	RPacketContext::TDataChannelV2 dataCh;
+	TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh);	
+	TMockLtsyData1< TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+	
+	// for the second request
+    TMockLtsyData2< TInfoName, TInfoName > ltsyExpect2(contextId2, hostCidName);
+	ltsyExpect2.SerialiseL(expectData2);
+	
+	TRequestStatus requestStatus2;
+	RPacketContext::TDataChannelV2 dataCh2;
+	TPckg<RPacketContext::TDataChannelV2> pckgInit2(dataCh2);	
+	TMockLtsyData1< TInfoName > ltsyData2(contextId2);
+	ltsyData2.SerialiseL(data2);
+	
+	iMockLTSY.ExpectL(EPacketContextInitialiseContext, expectData);	
+	iMockLTSY.CompleteL(EPacketContextInitialiseContext, KErrNone, data);
+	
+	iMockLTSY.ExpectL(EPacketContextInitialiseContext, expectData2);	
+	iMockLTSY.CompleteL(EPacketContextInitialiseContext, KErrNone, data2);
+	
+	//first request
+	packetContext.InitialiseContext(requestStatus, pckgInit);
+	
+	//second request
+	packetContext2.InitialiseContext(requestStatus2, pckgInit2);	
+		
+	// wait for the first answer
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	RPacketContext::TDataChannelV2 retDataChannel = pckgInit();
+    ASSERT_FALSE(retDataChannel.iChannelId.Compare(contextId));
+         
+    // wait for the second answer
+	User::WaitForRequest(requestStatus2);		
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());	
+	
+    retDataChannel = pckgInit2();
+    ASSERT_FALSE(retDataChannel.iChannelId.Compare(contextId2));
+        	
+    AssertMockLtsyStatusL();	 	
+	CleanupStack::PopAndDestroy(8, this); //packetContext2, packetContext, packetService, expectData, expectData2, data, data2, this
+
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCIC-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::InitialiseContext with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::InitialiseContext and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestInitialiseContext0005L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test timeout of RPacketContext::InitialiseContext
+ 	//-------------------------------------------------------------------------
+	TRequestStatus requestStatus;
+	RPacketContext::TDataChannelV2 dataCh;
+	TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh);	
+	
+	TInfoName hostCidName;
+    TMockLtsyData2< TInfoName, TInfoName > ltsyExpect(contextId, hostCidName);
+	ltsyExpect.SerialiseL(expectData);
+
+	iMockLTSY.ExpectL(EPacketContextInitialiseContext, expectData);
+		
+	packetContext.InitialiseContext(requestStatus, pckgInit);
+	
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
+
+	// Done !
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4, this); //packetService, packetContext, expectData, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGCS-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetConnectionSpeed
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetConnectionSpeed
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetConnectionSpeed0001L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+ 	//-------------------------------------------------------------------------
+	// TEST D: RPacketContext::ModifyActiveContext again, this time CTSY
+	// will get result from the cache.
+ 	//-------------------------------------------------------------------------
+	TRequestStatus requestStatus;
+	TUint rate;
+	TUint null = 0;
+	packetContext.GetConnectionSpeed(requestStatus, rate);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(null, rate);
+	AssertMockLtsyStatusL();
+	
+	//-------------------------------------------------------------------------
+	// Now change the Connection Speed
+	// and check that GetConnectionSpeed return appropriate value
+ 	//-------------------------------------------------------------------------
+	TRequestStatus mockLtsyStatus;	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	TInt connectionSpeed = 9600;	
+	TMockLtsyData2< TInfoName, TInt > ltsyData(contextId, connectionSpeed);
+	ltsyData.SerialiseL(data);
+	
+	// change the Connection Speed
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionSpeedChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	// get changed  Connection Speed
+	packetContext.GetConnectionSpeed(requestStatus, rate);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS((TUint)connectionSpeed, rate);
+	
+ 	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4, this); // packetContext, packetService, data, this	
+	}
+
+
+
+/**
+Cleanup CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>*
+*/
+void CCTsyPacketContextFU::CleanupArrayPtrFlat(TAny* aSelf)
+	{
+	if(aSelf)
+		{
+		CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* array (NULL);
+		array = static_cast<CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>*>(aSelf);
+		array->ResetAndDestroy();
+		delete array;
+		}	
+	}
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCMAC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::ModifyActiveContext
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::ModifyActiveContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestModifyActiveContext0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RBuf8 expectDataSPP;
+	CleanupClosePushL(expectDataSPP);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// initialisation of the context 
+	TInt err = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, err);
+		
+ 	//-------------------------------------------------------------------------
+	// TEST: call ModifyActiveContext when context wasn't active
+ 	//-------------------------------------------------------------------------	
+	TRequestStatus requestStatus;	
+	packetContext.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotReady, requestStatus.Int());
+	
+ 	
+ 	// Set context in Active state
+ 	err = SetContextActiveL(contextId);
+ 	ASSERT_EQUALS(KErrNone, err);	
+ 	
+	//-------------------------------------------------------------------------
+	// TEST: call ModifyActiveContext when context is active, but with no QoS object created
+ 	//------------------------------------------------------------------------- 	
+	packetContext.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrArgument, requestStatus.Int());	
+	
+	// ------ create New QoS -------------------------------------------------
+	RPacketQoS packetQoS;
+	TName qosName;
+	packetQoS.OpenNewQoS(packetContext, qosName);
+	CleanupClosePushL(packetQoS);	
+	//-------------------------------------------------------------------------
+	// TEST: call ModifyActiveContext when context is active, and QoS object is created, but 
+	// with no ProfileParameters
+ 	//------------------------------------------------------------------------- 
+ 	packetContext.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrArgument, requestStatus.Int());	
+ 	
+ 	
+	// ------ SetProfileParameters --------------------------------------------
+	RPacketQoS::TQoSGPRSRequested gprsRequested;	
+	TPckg<RPacketQoS::TQoSGPRSRequested> pckg(gprsRequested);
+	
+	// prepare data for expectDataSPP ... 
+	// ... context status
+	RPacketContext::TContextStatus contextStatus = RPacketContext::EStatusActive;
+	// ... get  contextConfig
+	RPacketContext::TContextConfigGPRS contextConfig;
+	TPckg< RPacketContext::TContextConfigGPRS > contextConfigPckg( contextConfig );	
+	packetContext.GetConfig(requestStatus, contextConfigPckg);
+	User::WaitForRequest(requestStatus);	
+	
+	// data for SetProfileParameters's ExpectL
+	TInfoName primaryContextName;	
+	TContextParams	contextParams;
+	contextParams.iContextName = contextId;
+	contextParams.iContextType = contextConfig.iNWIContext;
+	contextParams.iPdpType = contextConfig.iPdpType;
+	contextParams.iPrimaryContextName = primaryContextName;
+	contextParams.iContextStatus = contextStatus;		
+	TMockLtsyData2<TContextParams, RPacketQoS::TQoSGPRSRequested> 
+	                    expExpect(contextParams, gprsRequested);
+    expExpect.SerialiseL(expectDataSPP);
+	
+	iMockLTSY.ExpectL(EPacketQoSSetProfileParams, expectDataSPP);
+	packetQoS.SetProfileParameters(requestStatus, pckg);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	//-------------------------------------------------------------------------
+	// TEST A: failure to dispatch request to LTSY
+ 	//-------------------------------------------------------------------------
+ 	// data for ExpectL
+ 	RPacketQoS::TQoSGPRSRequested* qosProfile97 = &gprsRequested;
+    	
+ 	TContextConfiguration expectConfig;
+ 	expectConfig.iContextName = contextId;
+    expectConfig.iQosParams97 = qosProfile97;
+    expectConfig.iQosParams99 = NULL;
+	expectConfig.iQosParamsR5 = NULL;
+    expectConfig.iConfiguration = RPacketContext::EPdpTypeIPv4;    	 	
+ 	
+	CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* mediaAuthorizationArray(NULL);
+ 	TMockLtsyData2 < TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* > 
+ 																			ltsyExpect(expectConfig, mediaAuthorizationArray);
+	ltsyExpect.SerialiseL(expectData);	 	
+ 	//ExpectL
+ 	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData, KErrNotSupported);
+ 	
+ 	packetContext.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	
+
+	//-------------------------------------------------------------------------
+	// TEST B: failure on completion of pending request from LTSY->CTSY
+ 	//-------------------------------------------------------------------------
+ 	TBuf8<1> rejectionCode(1);
+ 	TMockLtsyData2 < TInfoName, TBuf8<1> > ltsyData2(contextId, rejectionCode);
+	ltsyData2.SerialiseL(data);
+ 	
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrGeneral, data);
+ 	packetContext.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::ModifyActiveContext when result is not cached.
+ 	//-------------------------------------------------------------------------
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data);
+ 	packetContext.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	//-------------------------------------------------------------------------
+	// TEST Successful completion request of
+	// RPacketContext::ModifyActiveContext with some filter added
+ 	//-------------------------------------------------------------------------	
+	// Open new secondary context
+	TInfoName contextIdSecondary;	
+	RPacketContext packetContextSecondary;
+	err = packetContextSecondary.OpenNewSecondaryContext(packetService, contextId, contextIdSecondary);
+ 	ASSERT_EQUALS(KErrNone, err);	
+	CleanupClosePushL(packetContextSecondary);
+	
+    // setting environement (add media authorization to CTSY)
+	mediaAuthorizationArray = new(ELeave) CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>(1);
+	CleanupStack::PushL(TCleanupItem(CleanupArrayPtrFlat,mediaAuthorizationArray));
+
+    RPacketContext::CTFTMediaAuthorizationV3* media  = RPacketContext::CTFTMediaAuthorizationV3::NewL(); 
+    CleanupStack::PushL(media);
+    media->iAuthorizationToken = _L8("testtok");
+    RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier fid;
+	fid.iIPFlowNumber = 2;
+	fid.iMediaComponentNumber = 3;
+	media->iFlowIds.Append(fid);
+	fid.iIPFlowNumber = 4;
+	fid.iMediaComponentNumber = 5;
+	media->iFlowIds.Append(fid);
+	mediaAuthorizationArray->AppendL(media);
+	CleanupStack::Pop(); //media
+ 	
+ 	// update contextConfig
+ 	packetContext.GetConfig(requestStatus, contextConfigPckg);	
+	User::WaitForRequest(requestStatus);
+	
+	TMockLtsyContextData2<TInfoName, RPacketContext::CTFTMediaAuthorizationV3* > 
+		expAddData(contextConfig, 0, contextIdSecondary, media);
+	data.Close();
+	expAddData.SerialiseL(data);
+    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data);
+
+ 	TMockLtsyData1<TInfoName > contexName(contextIdSecondary);
+	data.Close();
+    contexName.SerialiseL(data);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data);
+
+ 	packetContextSecondary.AddMediaAuthorizationL(requestStatus, *media);	
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	AssertMockLtsyStatusL();
+
+	// set context Active
+	SetContextActiveL(contextIdSecondary);
+	AssertMockLtsyStatusL();
+	
+	RPacketQoS packetQoSSecondary;
+	RPacketQoS::TQoSGPRSRequested secondaryRequested;
+	err = CreateQoSAndSetProfileParamLC(packetQoSSecondary, packetContextSecondary,
+											 contextIdSecondary, secondaryRequested, contextId);// contextId -- is name of "primary" context
+	ASSERT_EQUALS(KErrNone, err);
+	AssertMockLtsyStatusL();
+	
+	// Add filter
+	RPacketContext::TPacketFilterV2 filter;
+	filter.iId = 1;
+	RPacketContext::TPacketFilterV2Pckg filterPckg (filter);
+	err = AddContextPacketFilterL(packetContextSecondary, contextIdSecondary,filter, ETrue);// ETrue means that this request doesn't reache LTSY
+	ASSERT_EQUALS(KErrNone, err);
+	AssertMockLtsyStatusL();		
+	
+	// data for ExpectL    	
+	expectConfig.iContextName = contextIdSecondary;
+	expectConfig.iQosParams97 = &secondaryRequested;
+	expectConfig.iQosParams99 = NULL;
+	expectConfig.iQosParamsR5 = NULL;
+	expectConfig.iConfiguration = RPacketContext::EPdpTypeIPv4;    	 	
+ 	
+ 	TMockLtsyData2 < TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* > 
+	                                                     ltsyExpect2(expectConfig, mediaAuthorizationArray);
+	expectData.Close();
+	ltsyExpect2.SerialiseL(expectData); 
+	
+	// data for CompleteL
+	TMockLtsyData2 < TInfoName, TBuf8<1> > ltsyData3(contextIdSecondary, rejectionCode);
+	data.Close();
+	ltsyData3.SerialiseL(data);
+	
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data);
+ 	packetContextSecondary.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	
+	//-------------------------------------------------------------------------
+	// TEST Successful completion request of
+	// RPacketContext::ModifyActiveContext with some filter removed
+ 	//-------------------------------------------------------------------------	
+	TInt filterId = 1;
+	packetContextSecondary.RemovePacketFilter(requestStatus, filterId);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+	AssertMockLtsyStatusL();		
+	
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data);
+ 	packetContextSecondary.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+
+  	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::ModifyActiveContext
+	// from LTSY.
+ 	//-------------------------------------------------------------------------	
+ 	TRequestStatus mockLtsyStatus;
+ 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	
+	//send completion
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4);	// packetQoSSecondary, mediaAuthorizationArray, packetContextSecondary, packetQoS
+	CleanupStack::PopAndDestroy(6, this); //packetContext, packetService, expectDataSPP, expectData, data, this
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCMAC-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::ModifyActiveContext
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::ModifyActiveContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestModifyActiveContext0002L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+		
+ 	// Set context in Active state
+ 	status = SetContextActiveL(contextId);
+ 	ASSERT_EQUALS(KErrNone, status);
+ 	
+ 	//SetProfileParameters
+ 	RPacketQoS::TQoSGPRSRequested gprsRequested;
+ 	RPacketQoS packetQoS;
+ 	status = CreateQoSAndSetProfileParamLC(packetQoS, packetContext ,contextId, gprsRequested);
+	ASSERT_EQUALS(KErrNone, status);
+
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::ModifyActiveContext
+ 	//-------------------------------------------------------------------------
+ 	// data for ExpectL
+ 	RPacketQoS::TQoSGPRSRequested* qosProfile97 = &gprsRequested;
+    	
+	CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* expectArray = NULL;
+ 	TContextConfiguration expectConfig;
+ 	expectConfig.iContextName = contextId;
+    expectConfig.iQosParams97 = qosProfile97;
+    expectConfig.iQosParams99 = NULL;
+	expectConfig.iQosParamsR5 = NULL;
+    expectConfig.iConfiguration = RPacketContext::EPdpTypeIPv4;    	 	
+ 	
+ 	TMockLtsyData2 < TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* > 
+ 																			ltsyExpect(expectConfig, expectArray);
+	ltsyExpect.SerialiseL(expectData);	 
+ 	
+ 	TRequestStatus requestStatus;
+ 	
+ 	// data for CompleteL
+	TBuf8<1> rejectionCode(1);
+ 	TMockLtsyData2 < TInfoName, TBuf8<1> > ltsyData2(contextId, rejectionCode);
+	ltsyData2.SerialiseL(data);
+ 	
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data, 10);
+ 	packetContext.ModifyActiveContext(requestStatus);
+ 	 	
+ 	// cancel request
+ 	packetContext.CancelAsyncRequest(EPacketContextModifyActiveContext); 	
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	// TSY has started a request and it is not possible to then cancel 
+    // this request. The best thing for the TSY to do in this case is to
+    // proceed as though the Cancel never happened.		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	CleanupStack::PopAndDestroy();//packetQoS
+	CleanupStack::PopAndDestroy(5, this); // packetService, packetContext,  expectData, data,  this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCMAC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::ModifyActiveContext
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::ModifyActiveContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestModifyActiveContext0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RBuf8 expectData2;
+	CleanupClosePushL(expectData2);
+	
+	RBuf8 expectData3;
+	CleanupClosePushL(expectData3);
+	
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService, contextId2);
+	CleanupClosePushL(packetContext2);
+	
+	// Open third context
+	TInfoName contextId3;	
+	RPacketContext packetContext3;
+	packetContext3.OpenNewContext(packetService, contextId3);
+	CleanupClosePushL(packetContext3);
+
+	// initialisation of the first context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+		
+ 	// Set first context in Active state
+ 	status = SetContextActiveL(contextId);
+ 	ASSERT_EQUALS(KErrNone, status);
+ 	
+ 	//SetProfileParameters first context's
+ 	RPacketQoS::TQoSGPRSRequested gprsRequested;
+ 	RPacketQoS packetQoS;
+ 	status = CreateQoSAndSetProfileParamLC(packetQoS, packetContext,contextId, gprsRequested);
+	ASSERT_EQUALS(KErrNone, status);
+	
+	
+	// initialisation of the second context 
+	status = InitContextL(packetContext2, contextId2);
+	ASSERT_EQUALS(KErrNone, status);
+		
+ 	// Set second context in Active state
+ 	status = SetContextActiveL(contextId2);
+ 	ASSERT_EQUALS(KErrNone, status);
+ 	
+ 	//SetProfileParameters second context's
+ 	RPacketQoS::TQoSR99_R4Requested rel99Requested;
+ 	RPacketQoS packetQoS2;
+ 	status = CreateQoSAndSetProfileParamLC(packetQoS2, packetContext2, contextId2, rel99Requested);
+	ASSERT_EQUALS(KErrNone, status);
+	
+	
+	// initialisation of the third context 
+	status = InitContextL(packetContext3, contextId3);
+	ASSERT_EQUALS(KErrNone, status);
+		
+ 	// Set third context in Active state
+ 	status = SetContextActiveL(contextId3);
+ 	ASSERT_EQUALS(KErrNone, status);
+ 	
+ 	//SetProfileParameters third context's
+ 	RPacketQoS::TQoSR5Requested r5Requested;	
+	RPacketQoS packetQoS3;
+ 	status = CreateQoSAndSetProfileParamLC(packetQoS3, packetContext3, contextId3, r5Requested);
+	ASSERT_EQUALS(KErrNone, status);
+		
+ 	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::ModifyActiveContext
+ 	//------------------------------------------------------------------------- 	
+	TBuf8<1> rejectionCode(1);
+	// data for the first ExpectL     	
+	CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* expectArray = NULL;
+ 	TContextConfiguration expectConfig;
+ 	expectConfig.iContextName = contextId;
+    expectConfig.iQosParams97 = &gprsRequested;
+    expectConfig.iQosParams99 = NULL;
+	expectConfig.iQosParamsR5 = NULL;
+    expectConfig.iConfiguration = RPacketContext::EPdpTypeIPv4;    	 	
+ 	
+ 	TMockLtsyData2 < TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* > 
+ 																			ltsyExpect(expectConfig, expectArray);
+	ltsyExpect.SerialiseL(expectData);	 
+	
+	// data for the second ExpectL 
+  	TContextConfiguration expectConfig2;
+ 	expectConfig2.iContextName = contextId2;
+    expectConfig2.iQosParams97 = NULL;
+    expectConfig2.iQosParams99 = &rel99Requested;
+	expectConfig2.iQosParamsR5 = NULL;
+    expectConfig2.iConfiguration = RPacketContext::EPdpTypeIPv4;    	 	
+ 	
+ 	TMockLtsyData2 < TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* > 
+ 																			ltsyExpect2(expectConfig2, expectArray);
+	ltsyExpect2.SerialiseL(expectData2);	 
+	
+	// data for the third ExpectL 
+  	TContextConfiguration expectConfig3;
+ 	expectConfig3.iContextName = contextId3;
+    expectConfig3.iQosParams97 = NULL;
+    expectConfig3.iQosParams99 = NULL;
+	expectConfig3.iQosParamsR5 = &r5Requested;
+    expectConfig3.iConfiguration = RPacketContext::EPdpTypeIPv4;    	 	
+ 	
+ 	TMockLtsyData2 < TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* > 
+ 																			ltsyExpect3(expectConfig3, expectArray);
+	ltsyExpect3.SerialiseL(expectData3);	 
+	
+  
+    // prepare and send first request
+	TMockLtsyData2 < TInfoName, TBuf8<1> > dataForComplete(contextId, rejectionCode);
+	dataForComplete.SerialiseL(data);	 	
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data, 10);  	
+ 	TRequestStatus requestStatus; 	
+ 	packetContext.ModifyActiveContext(requestStatus);
+ 
+	// prepare and send first request 
+ 	TMockLtsyData2 < TInfoName, TBuf8<1> > dataForComplete2(contextId2, rejectionCode);
+	data.Close();
+	dataForComplete2.SerialiseL(data);
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData2);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data, 10); 	
+ 	TRequestStatus requestStatus2;
+ 	packetContext2.ModifyActiveContext(requestStatus2); 	
+ 	
+ 	// prepare and send third request 
+ 	TMockLtsyData2 < TInfoName, TBuf8<1> > dataForComplete3(contextId3, rejectionCode);
+	data.Close();
+	dataForComplete3.SerialiseL(data);
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData3);
+	iMockLTSY.CompleteL(EPacketContextModifyActiveContext, KErrNone, data, 10); 	
+ 	TRequestStatus requestStatus3;
+ 	packetContext3.ModifyActiveContext(requestStatus3);  	
+ 	
+ 	// wait for first answer
+ 	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	// wait for second answer
+	User::WaitForRequest(requestStatus2);		
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+	
+	// wait for third answer
+	User::WaitForRequest(requestStatus3);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus3.Int());
+	
+	CleanupStack::PopAndDestroy(3); // packetQoS, packetQoS2, packetQoS3, 
+	CleanupStack::PopAndDestroy(11, this); //packetContext, packetContext2,packetContext3
+											//packetService, phone2,telServer2, 
+										   //expectData3, expectData2, expectData, data, this									   
+
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCMAC-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::ModifyActiveContext with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::ModifyActiveContext and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestModifyActiveContext0005L()
+	{
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	
+	// initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+		
+ 	// Set context in Active state
+ 	status = SetContextActiveL(contextId);
+ 	ASSERT_EQUALS(KErrNone, status);
+ 	
+ 	//SetProfileParameters
+ 	RPacketQoS::TQoSGPRSRequested gprsRequested;
+ 	RPacketQoS packetQoS;
+ 	status = CreateQoSAndSetProfileParamLC(packetQoS, packetContext, contextId, gprsRequested);
+	ASSERT_EQUALS(KErrNone, status);
+	
+	//-------------------------------------------------------------------------
+	// Test A: Test timeout of RPacketContext::ModifyActiveContext
+ 	//------------------------------------------------------------------------- 
+ 	TRequestStatus requestStatus; 	
+ 	// data for ExpectL
+ 	RPacketQoS::TQoSGPRSRequested* qosProfile97 = &gprsRequested;    	
+	CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* expectArray = NULL;
+ 	TContextConfiguration expectConfig;
+ 	expectConfig.iContextName = contextId;
+    expectConfig.iQosParams97 = qosProfile97;
+    expectConfig.iQosParams99 = NULL;
+	expectConfig.iQosParamsR5 = NULL;
+    expectConfig.iConfiguration = RPacketContext::EPdpTypeIPv4;    	 	
+ 	
+ 	TMockLtsyData2 < TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* > 
+ 																			ltsyExpect(expectConfig, expectArray);
+	ltsyExpect.SerialiseL(expectData);	 	
+	
+	iMockLTSY.ExpectL(EPacketContextModifyActiveContext, expectData);
+	
+ 	packetContext.ModifyActiveContext(requestStatus); 	
+ 		
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
+
+	CleanupStack::PopAndDestroy(6, this); //packetQoS, packetService, packetContext, expectData, data, this
+
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyConfigChanged
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::NotifyConfigChanged
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConfigChanged0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::NotifyConfigChanged when result is not cached.
+ 	//-------------------------------------------------------------------------
+	// data for NotifyConfigChanged	
+	TRequestStatus requestStatus;
+	RPacketContext::TContextConfigGPRS contextConfig;	
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig);	
+	
+	//data for ComleteL   
+ 	RPacketContext::TContextConfigGPRS configComplete;  	 	
+ 	// (just this data is copied in CMmPacketContextGsmWcdmaExt::CompleteActivatePhase2 
+	// see CMmPacketContextGsmWcdma.cpp line 339) 	  
+    _LIT(KPointName, "Some Name");
+    configComplete.iAccessPointName.Copy(KPointName);
+    _LIT(KPdpAdd, "Some Add");
+    configComplete.iPdpAddress.Copy(KPdpAdd);    	
+	configComplete.iPdpCompression = RPacketContext::KPdpDataCompression;		
+	_LIT(KPrimaryDns, "Some PrimaryDns");
+	configComplete.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	_LIT(KSecondaryDns, "Some SecondaryDns");
+	configComplete.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);	
+ 	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigGPRS > ltsyData(contextId, configComplete);
+	ltsyData.SerialiseL(data);	
+
+	// send request	
+	packetContext.NotifyConfigChanged(requestStatus, pckgConfig);
+		
+	// sent completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+		
+	// wait for request
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+	ASSERT_EQUALS(configComplete.iAccessPointName, 		contextConfig.iAccessPointName);
+	ASSERT_EQUALS(configComplete.iPdpAddress, 			contextConfig.iPdpAddress );
+	ASSERT_EQUALS(configComplete.iPdpCompression, 		contextConfig.iPdpCompression);
+	ASSERT_EQUALS(configComplete.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, 	contextConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(configComplete.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, contextConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);	
+
+	
+ 	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::NotifyConfigChanged
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	// sent completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	AssertMockLtsyStatusL();	
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	CleanupStack::PopAndDestroy(2); // packetService, packetContext
+	CleanupStack::PopAndDestroy(2, this); // data, this	
+	}
+	
+	
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCC-0001b
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyConfigChanged
+@SYMTestPriority High
+@SYMTestActions Invokes CMmPacketServiceTsy::DialUpContext via RPacketContext::NotifyConfigChanged
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConfigChanged0001bL()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+
+	
+ 	//-------------------------------------------------------------------------
+	// call completition of RPacketContext::NotifyConfigChanged
+	// to call CMmPacketServiceTsy::DialUpContext
+	// with ContextID ==  KStringExternal
+ 	//------------------------------------------------------------------------- 	
+ 	//data for ComleteL   
+ 	RPacketContext::TContextConfigGPRS configComplete;  	 
+ 	TInfoName ContextID;	
+ 	_LIT( KStringExternal,  "External"  );
+ 	ContextID.Copy(KStringExternal);
+  	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigGPRS > ltsyData(ContextID, configComplete);
+	ltsyData.SerialiseL(data);	
+ 	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	// sent completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	AssertMockLtsyStatusL();	
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	
+	//-------------------------------------------------------------------------
+	// call completition of RPacketContext::NotifyConfigChanged
+	// to call CMmPacketServiceTsy::DialUpContext
+	// with ContextID ==  KStringExternal2
+ 	//------------------------------------------------------------------------- 	
+ 	//data for ComleteL     	 
+  	_LIT( KStringExternal2,  "External2"  );
+ 	ContextID.Copy(KStringExternal2);
+  	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigGPRS > ltsyData2(ContextID, configComplete);
+	data.Close();
+	ltsyData2.SerialiseL(data);	
+ 	
+ 	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	// sent completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	AssertMockLtsyStatusL();	
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	
+	//-------------------------------------------------------------------------
+	// call completition of RPacketContext::NotifyConfigChanged
+	// to call CMmPacketServiceTsy::DialUpContext
+	// with (ContextID !=  KStringExternal2)&&(ContextID !=  KStringExternal)
+ 	//------------------------------------------------------------------------- 	
+ 	//data for ComleteL     	 
+  	_LIT( KSomeId,  "SomeId"  );
+ 	ContextID.Copy(KSomeId);
+  	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigGPRS > ltsyData3(ContextID, configComplete);
+	data.Close();
+	ltsyData3.SerialiseL(data);
+ 	
+ 	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	// sent completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	AssertMockLtsyStatusL();	
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	
+	CleanupStack::PopAndDestroy(2); // packetService, packetContext
+	CleanupStack::PopAndDestroy(2, this); // data, this	
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCC-0001c
+@SYMComponent  telephony_ctsy
+@SYMDEF DEF126915
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyConfigChanged using R99/R4 Context params
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::NotifyConfigChange. R99/R4 Context params returned
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConfigChanged0001cL()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::NotifyConfigChanged, using TContextConfigR99_R4 return 
+	// params, when result is not cached.
+ 	//-------------------------------------------------------------------------
+	// data for NotifyConfigChanged	
+	TRequestStatus requestStatus;
+	RPacketContext::TContextConfigGPRS contextConfig;	
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig);	
+	
+	//data for ComleteL   
+ 	RPacketContext::TContextConfigR99_R4 configComplete;  	 	
+ 	// (just this data is copied in CMmPacketContextGsmWcdmaExt::CompleteActivatePhase2 
+	// see CMmPacketContextGsmWcdma.cpp line 339) 	  
+    _LIT(KPointName, "Some Name");
+    configComplete.iAccessPointName.Copy(KPointName);
+    _LIT(KPdpAdd, "Some Add");
+    configComplete.iPdpAddress.Copy(KPdpAdd);    	
+	_LIT(KPrimaryDns, "Some PrimaryDns");
+	configComplete.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	_LIT(KSecondaryDns, "Some SecondaryDns");
+	configComplete.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);	
+ 	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigR99_R4 > ltsyData(contextId, configComplete);
+	ltsyData.SerialiseL(data);	
+
+	// send request	
+	packetContext.NotifyConfigChanged(requestStatus, pckgConfig);
+		
+	// sent completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+		
+	// wait for request
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+	ASSERT_EQUALS(configComplete.iAccessPointName, 		contextConfig.iAccessPointName);
+	ASSERT_EQUALS(configComplete.iPdpAddress, 			contextConfig.iPdpAddress );
+	ASSERT_EQUALS(configComplete.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, 	contextConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(configComplete.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, contextConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);	
+
+	CleanupStack::PopAndDestroy(2); // packetService, packetContext
+	CleanupStack::PopAndDestroy(2, this); // data, this	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCC-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::NotifyConfigChanged
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::NotifyConfigChanged
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConfigChanged0002L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::NotifyConfigChanged
+ 	//------------------------------------------------------------------------- 	
+	// data for NotifyConfigChanged	
+	TRequestStatus requestStatus;
+	RPacketContext::TContextConfigGPRS contextConfig;	
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig);	
+	
+	//data for ComleteL    
+ 	RPacketContext::TContextConfigGPRS configComplete;
+ 	_LIT (KNewName, "Some new Name");
+ 	configComplete.iPdpAddress.Copy(KNewName); 	
+ 	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigGPRS > ltsyData(contextId, configComplete);
+	ltsyData.SerialiseL(data);	
+
+	// send request	
+	packetContext.NotifyConfigChanged(requestStatus, pckgConfig);	
+	//send cancellation
+	packetContext.CancelAsyncRequest(EPacketContextNotifyConfigChanged);
+		
+	// sent completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	
+	// wait for request
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+	CleanupStack::PopAndDestroy(2); // packetService, packetContext
+	CleanupStack::PopAndDestroy(2); // data, this	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCC-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyConfigChanged with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::NotifyConfigChanged with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConfigChanged0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test passing wrong version of parameters to
+	// RPacketContext::NotifyConfigChanged
+ 	//-------------------------------------------------------------------------
+	// data for NotifyConfigChanged	
+	TRequestStatus requestStatus;
+	RPacketContext::TContextConfigCDMA contextConfig;	
+	TPckg<RPacketContext::TContextConfigCDMA> pckgConfig(contextConfig);	
+
+	// send request	
+	packetContext.NotifyConfigChanged(requestStatus, pckgConfig);
+
+	// wait for request
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+	CleanupStack::PopAndDestroy(2); // packetService, packetContext
+	CleanupStack::PopAndDestroy(2, this); // data, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::NotifyConfigChanged
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::NotifyConfigChanged
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConfigChanged0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::NotifyConfigChanged
+ 	//-------------------------------------------------------------------------
+	
+	// data for NotifyConfigChanged	1
+	TRequestStatus requestStatus;
+	RPacketContext::TContextConfigGPRS contextConfig1;	
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfig1(contextConfig1);	
+	
+	//data for ComleteL 1   
+ 	RPacketContext::TContextConfigGPRS configComplete1;
+ 	// (just this data is copied in CMmPacketContextGsmWcdmaExt::CompleteActivatePhase2 
+	// see CMmPacketContextGsmWcdma.cpp line 339) 	  
+    _LIT(KPointName, "Some Name");
+    configComplete1.iAccessPointName.Copy(KPointName);
+    _LIT(KPdpAdd, "Some Add");
+    configComplete1.iPdpAddress.Copy(KPdpAdd);    	
+	configComplete1.iPdpCompression = RPacketContext::KPdpDataCompression;		
+	_LIT(KPrimaryDns, "Some PrimaryDns");
+	configComplete1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	_LIT(KSecondaryDns, "Some SecondaryDns");
+	configComplete1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);	 	
+ 	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigGPRS > ltsyData(contextId, configComplete1);
+	ltsyData.SerialiseL(data);
+	
+	
+	// data for NotifyConfigChanged	2
+	TRequestStatus requestStatus2;
+	RPacketContext::TContextConfigR99_R4 contextConfig2;	
+	TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig2(contextConfig2);	
+	
+	//data for ComleteL 2 
+ 	RPacketContext::TContextConfigGPRS configComplete2; 
+ 	// (just this data is copied in CMmPacketContextGsmWcdmaExt::CompleteActivatePhase2 
+	// see CMmPacketContextGsmWcdma.cpp line 339) 	  
+    _LIT(KPointName2, "Some Name2");
+    configComplete2.iAccessPointName.Copy(KPointName2);
+    _LIT(KPdpAdd2, "Some Add2");
+    configComplete2.iPdpAddress.Copy(KPdpAdd2);    	
+	configComplete2.iPdpCompression = RPacketContext::KPdpDataCompression;		
+	_LIT(KPrimaryDns2, "Some PrimaryDns2");
+	configComplete2.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns2);
+	_LIT(KSecondaryDns2, "Some SecondaryDns2");
+	configComplete2.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns2);
+ 	TMockLtsyData2 < TInfoName, RPacketContext::TContextConfigGPRS > ltsyData2(contextId2, configComplete2);
+	ltsyData2.SerialiseL(data2);
+	
+	// send first request	
+	packetContext.NotifyConfigChanged(requestStatus, pckgConfig1);
+	
+	// send second request	
+	packetContext2.NotifyConfigChanged(requestStatus2, pckgConfig2);
+	
+	// sent first completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data);
+	
+	// sent second completion
+	iMockLTSY.CompleteL(EPacketContextNotifyConfigChanged, KErrNone, data2);	
+	
+	// wait for first answer
+	User::WaitForRequest(requestStatus);
+		
+	// wait for second answer
+	User::WaitForRequest(requestStatus2);	
+	AssertMockLtsyStatusL();		
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+	
+	
+	ASSERT_EQUALS(configComplete1.iAccessPointName, 	contextConfig1.iAccessPointName);
+	ASSERT_EQUALS(configComplete1.iPdpAddress, 			contextConfig1.iPdpAddress );
+	ASSERT_EQUALS(configComplete1.iPdpCompression, 		contextConfig1.iPdpCompression);
+	ASSERT_EQUALS(configComplete1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, 	
+				  contextConfig1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(configComplete1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns,
+				  contextConfig1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);
+				  	
+	ASSERT_EQUALS(configComplete2.iAccessPointName, 	contextConfig2.iAccessPointName);
+	ASSERT_EQUALS(configComplete2.iPdpAddress, 			contextConfig2.iPdpAddress);
+	ASSERT_EQUALS(configComplete2.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, 	 
+				  contextConfig2.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(configComplete2.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, 
+				  contextConfig2.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);
+				  
+	CleanupStack::PopAndDestroy(9, this); //packetContext2, packetContext, packetService2, packetService, phone2, telServer2, data,data2 this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNDT-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyDataTransferred
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::NotifyDataTransferred
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyDataTransferred0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+		
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+		
+	//-------------------------------------------------------------------------
+	//check that this requests is not supported by CTSY
+ 	//-------------------------------------------------------------------------	
+	TRequestStatus requestStatus;
+	RPacketContext::TDataVolume volume;
+	TUint rcvdGranularity = 1;
+	TUint sentGranularity = 1;
+	
+	packetContext.NotifyDataTransferred(requestStatus, volume, rcvdGranularity, sentGranularity);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	
+	
+	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::NotifyConfigChanged
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+ 	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	RPacketContext::TDataVolume dataVolume;
+	dataVolume. iBytesReceived = 111;	
+	TMockLtsyData2 < TInfoName, RPacketContext::TDataVolume > ltsyData(contextId, dataVolume);
+	ltsyData.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyDataTransferred, KErrNone, data);
+	
+	User::WaitForRequest(mockLtsyStatus);		
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4, this); // packetService, packetContext, data, this	
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCEPF-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::EnumeratePacketFilters
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::EnumeratePacketFilters
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestEnumeratePacketFilters0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	// Open new context 
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+	
+  	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::EnumeratePacketFilters when result is not cached.
+ 	//-------------------------------------------------------------------------
+	TRequestStatus requestStatus;
+	TInt count = 11;  // some nonzero value 
+	packetContext.EnumeratePacketFilters(requestStatus, count);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(0, count);
+	
+	
+	//-------------------------------------------------------------------------
+	// Add filter and test again
+ 	//-------------------------------------------------------------------------	
+	// Open new secondary context
+	TInfoName contextIdSecondary;	
+	RPacketContext packetContextSecondary;
+	packetContextSecondary.OpenNewSecondaryContext(packetService, contextId, contextIdSecondary);
+	CleanupClosePushL(packetContextSecondary);
+			
+	RPacketQoS packetQoSSecondary;
+	RPacketQoS::TQoSGPRSRequested secondaryRequested;
+	TInt err = CreateQoSAndSetProfileParamLC(packetQoSSecondary, packetContextSecondary,
+											 contextIdSecondary, secondaryRequested, contextId);	
+	ASSERT_EQUALS(KErrNone, err);	
+	CleanupClosePushL(packetQoSSecondary);
+		
+	// add new filter
+	RPacketContext::TPacketFilterV2 filter;
+	filter.iId = 1;
+	RPacketContext::TPacketFilterV2Pckg filterPckg (filter);	
+	err = AddContextPacketFilterL(packetContextSecondary, contextIdSecondary, filter);
+		
+	ASSERT_EQUALS(KErrNone, err);	
+		
+	// send request
+	packetContextSecondary.EnumeratePacketFilters(requestStatus, count);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(1, count);		
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(7, this); // packetQoSSecondary, packetContextSecondary, packetService, packetContext,data, this	
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCEPF-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::EnumeratePacketFilters
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::EnumeratePacketFilters
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestEnumeratePacketFilters0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::EnumeratePacketFilters
+ 	//-------------------------------------------------------------------------
+	
+	TRequestStatus requestStatus;
+	TInt count = 11;  // some nonzero value 
+	TRequestStatus requestStatus2;
+	TInt count2 = 22;  // some nonzero value 
+	
+	// send first request
+	packetContext.EnumeratePacketFilters(requestStatus, count);
+	// send second request
+	packetContext2.EnumeratePacketFilters(requestStatus2, count2);
+	
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(0, count);
+	
+	User::WaitForRequest(requestStatus2);		
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+	ASSERT_EQUALS(0, count2);
+		
+	CleanupStack::PopAndDestroy(7, this); // packetContext2, packetContext, packetService2, packetService, phone2, telServer2, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGDVT-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetDataVolumeTransferred
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetDataVolumeTransferred
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetDataVolumeTransferred0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;	
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);		
+		
+ 	//-------------------------------------------------------------------------
+	// TEST A: failure to dispatch request to LTSY
+ 	//-------------------------------------------------------------------------
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+ 	
+	iMockLTSY.ExpectL(EPacketContextGetDataVolumeTransferred,expectData, KErrNotSupported);	
+	
+	TRequestStatus requestStatus;
+	RPacketContext::TDataVolume volume;	
+	packetContext.GetDataVolumeTransferred(requestStatus, volume);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+	AssertMockLtsyStatusL();
+
+	//-------------------------------------------------------------------------
+	// TEST B: failure on completion of pending request from LTSY->CTSY
+ 	//-------------------------------------------------------------------------	
+ 	// data for CompleteL
+ 	RPacketContext::TDataVolume volumeCompleteL;
+ 	volumeCompleteL.iBytesReceived = 0x111;
+ 	volumeCompleteL.iBytesSent     = 0x222;
+ 	TMockLtsyData2 <TInfoName, RPacketContext::TDataVolume > ltsyData1(contextId, volumeCompleteL);
+	ltsyData1.SerialiseL(data);
+ 	
+ 	iMockLTSY.ExpectL(EPacketContextGetDataVolumeTransferred, expectData);	 	
+ 	iMockLTSY.CompleteL(EPacketContextGetDataVolumeTransferred, KErrGeneral, data);	
+	
+	packetContext.GetDataVolumeTransferred(requestStatus, volume);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+	AssertMockLtsyStatusL();
+		
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::GetDataVolumeTransferred when result is not cached.
+ 	//-------------------------------------------------------------------------
+	iMockLTSY.ExpectL(EPacketContextGetDataVolumeTransferred, expectData);	 	
+ 	iMockLTSY.CompleteL(EPacketContextGetDataVolumeTransferred, KErrNone, data);	
+	
+	packetContext.GetDataVolumeTransferred(requestStatus, volume);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(volumeCompleteL.iBytesReceived, volume.iBytesReceived);
+	ASSERT_EQUALS(volumeCompleteL.iBytesSent, volume.iBytesSent);
+	AssertMockLtsyStatusL();
+
+  	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::GetDataVolumeTransferred
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	iMockLTSY.CompleteL(EPacketContextGetDataVolumeTransferred, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);		
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	AssertMockLtsyStatusL();
+		
+	//-------------------------------------------------------------------------
+	// TEST of RPacketContext::GetDataVolumeTransferred
+	// when ContextStatus == RPacketContext::EStatusDeleted in CMmPacketContextTsy
+ 	//------------------------------------------------------------------------- 		
+	
+	// set Context status as RPacketContext::EStatusDeleted	
+	TInt err = SetContextStatusL(contextId, RPacketContext::EStatusDeleted);
+	ASSERT_EQUALS(KErrNone, err);	
+	
+	// send request	
+	packetContext.GetDataVolumeTransferred(requestStatus, volume);
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(volumeCompleteL.iBytesReceived, volume.iBytesReceived);
+	ASSERT_EQUALS(volumeCompleteL.iBytesSent, volume.iBytesSent);		
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(5, this); // packetContext, packetService, expectData, data, this
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGDVT-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::GetDataVolumeTransferred
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::GetDataVolumeTransferred
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetDataVolumeTransferred0002L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;	
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);	
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::GetDataVolumeTransferred
+ 	//-------------------------------------------------------------------------
+ 	TRequestStatus requestStatus;
+	RPacketContext::TDataVolume volume;	
+	
+	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	// data for CompleteL
+ 	RPacketContext::TDataVolume volumeCompleteL;
+ 	volumeCompleteL.iBytesReceived = 0x111;
+ 	volumeCompleteL.iBytesSent     = 0x222;
+ 	TMockLtsyData2 <TInfoName, RPacketContext::TDataVolume > ltsyData1(contextId, volumeCompleteL);
+	ltsyData1.SerialiseL(data);
+ 	 	
+ 	iMockLTSY.ExpectL(EPacketContextGetDataVolumeTransferred, expectData);	 	
+ 	 	
+ 	// send request  	
+ 	packetContext.GetDataVolumeTransferred(requestStatus, volume);
+ 	
+ 	//sent cancelling
+ 	packetContext.CancelAsyncRequest(EPacketContextGetDataVolumeTransferred); 	
+ 	
+ 	//send complete request
+ 	iMockLTSY.CompleteL(EPacketContextGetDataVolumeTransferred, KErrNone, data, 10);
+ 	
+	User::WaitForRequest(requestStatus);		
+	// TSY has started a request and it is not possible to then cancel 
+    // this request. The best thing for the TSY to do in this case is to
+    // proceed as though the Cancel never happened.
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(volumeCompleteL.iBytesReceived, volume.iBytesReceived);
+	ASSERT_EQUALS(volumeCompleteL.iBytesSent, volume.iBytesSent);
+	AssertMockLtsyStatusL();	
+	
+	CleanupStack::PopAndDestroy(5, this); // packetContext, packetService,expectData, data, this	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGDVT-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::GetDataVolumeTransferred
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::GetDataVolumeTransferred
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetDataVolumeTransferred0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+		
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RBuf8 expectData2;
+	CleanupClosePushL(expectData2);
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::GetDataVolumeTransferred
+ 	//-------------------------------------------------------------------------
+
+	// data for first CompleteL
+ 	RPacketContext::TDataVolume volumeCompleteL;
+ 	volumeCompleteL.iBytesReceived = 0x111;
+ 	volumeCompleteL.iBytesSent     = 0x222;
+ 	TMockLtsyData2 <TInfoName, RPacketContext::TDataVolume > ltsyData1(contextId, volumeCompleteL);
+	ltsyData1.SerialiseL(data);
+	
+	// data for second CompleteL
+  	TMockLtsyData2 <TInfoName, RPacketContext::TDataVolume > ltsyData2(contextId2, volumeCompleteL);
+	ltsyData2.SerialiseL(data2);	
+	
+	// for the first request
+	TRequestStatus requestStatus;
+	RPacketContext::TDataVolume volume;
+	
+	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	// for the second request
+	TRequestStatus requestStatus2;
+	RPacketContext::TDataVolume volume2;
+	
+	TMockLtsyData1 <TInfoName> expData2(contextId2);
+	expData2.SerialiseL(expectData2);
+	
+	iMockLTSY.ExpectL(EPacketContextGetDataVolumeTransferred, expectData);	 	
+ 	iMockLTSY.CompleteL(EPacketContextGetDataVolumeTransferred, KErrNone, data);
+	iMockLTSY.ExpectL(EPacketContextGetDataVolumeTransferred, expectData2); 	 
+	iMockLTSY.CompleteL(EPacketContextGetDataVolumeTransferred, KErrNone, data2);
+	
+	// send first request
+	packetContext.GetDataVolumeTransferred(requestStatus, volume);		
+	
+	// send second request
+	packetContext2.GetDataVolumeTransferred(requestStatus2, volume2);
+	
+	// wait for first answer
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(volumeCompleteL.iBytesReceived, volume.iBytesReceived);
+	ASSERT_EQUALS(volumeCompleteL.iBytesSent, volume.iBytesSent);
+	
+	// wait for second answer
+	User::WaitForRequest(requestStatus2);		
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+	ASSERT_EQUALS(volumeCompleteL.iBytesReceived, volume2.iBytesReceived);
+	ASSERT_EQUALS(volumeCompleteL.iBytesSent, volume2.iBytesSent);
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(2); // expectData2, expectData
+	CleanupStack::PopAndDestroy(9, this); //packetContext2, packetContext, packetService2, packetService, phone2, telServer2, data,data2 this
+
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGDVT-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetDataVolumeTransferred with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetDataVolumeTransferred and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetDataVolumeTransferred0005L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;	
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test timeout of RPacketContext::GetDataVolumeTransferred
+ 	//------------------------------------------------------------------------- 	
+	
+	TRequestStatus requestStatus;
+	RPacketContext::TDataVolume volume;
+	
+	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	iMockLTSY.ExpectL(EPacketContextGetDataVolumeTransferred, expectData);
+	
+	packetContext.GetDataVolumeTransferred(requestStatus, volume);	
+	
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());	
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4, this); //packetContext, packetService,  expectData, this
+
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCSC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyConnectionSpeedChange
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::NotifyConnectionSpeedChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConnectionSpeedChange0001L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;	
+	packetContext.OpenNewContext(packetService, contextId);	
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);		
+	
+  	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::NotifyConnectionSpeedChange when result is not cached.
+ 	//-------------------------------------------------------------------------
+	// data for CompleteL
+	TInt completeRate = 9600;
+	TMockLtsyData2 <TInfoName, TInt > ltsyData(contextId, completeRate);
+	ltsyData.SerialiseL(data);	
+	
+	TRequestStatus requestStatus;
+	TUint rate;
+	// send request
+	packetContext.NotifyConnectionSpeedChange(requestStatus, rate);
+	
+	// send completion 
+	iMockLTSY.CompleteL (EPacketContextNotifyConnectionSpeedChange, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(completeRate, (TInt)rate);
+
+ 	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::NotifyConnectionSpeedChange
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	// send completion 
+	iMockLTSY.CompleteL (EPacketContextNotifyConnectionSpeedChange, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(4, this); //packetContext, packetService, data, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCSC-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::NotifyConnectionSpeedChange
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::NotifyConnectionSpeedChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConnectionSpeedChange0002L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;	
+	packetContext.OpenNewContext(packetService, contextId);	
+	CleanupClosePushL(packetContext);
+
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::NotifyConnectionSpeedChange
+ 	//-------------------------------------------------------------------------
+ 	
+	// data for CompleteL
+	TInt completeRate = 9600;
+	TMockLtsyData2 <TInfoName, TInt > ltsyData(contextId, completeRate);
+	ltsyData.SerialiseL(data);	
+	
+	TRequestStatus requestStatus;
+	TUint rate;
+	// send request
+	packetContext.NotifyConnectionSpeedChange(requestStatus, rate);
+	packetContext.CancelAsyncRequest(EPacketContextNotifyConnectionSpeedChange);
+	
+	// send completion 
+	iMockLTSY.CompleteL (EPacketContextNotifyConnectionSpeedChange, KErrNone, data);
+
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrCancel, requestStatus.Int());	
+
+	// Wait for completion of iMockLTSY.NotifyTerminated
+	User::WaitForRequest(mockLtsyStatus);	
+	AssertMockLtsyStatusL();		
+	CleanupStack::PopAndDestroy(4, this); //packetContext, packetService, data, this
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCSC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::NotifyConnectionSpeedChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::NotifyConnectionSpeedChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConnectionSpeedChange0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::NotifyConnectionSpeedChange
+ 	//-------------------------------------------------------------------------
+	TUint rate;	
+	TRequestStatus requestStatus;	
+	TRequestStatus requestStatus2;
+	TUint rate2;
+	
+		
+	// data for CompleteL 1
+	TInt completeRate = 9600;
+	TMockLtsyData2 <TInfoName, TInt > ltsyData(contextId, completeRate);
+	ltsyData.SerialiseL(data);
+
+	// data for CompleteL 2
+	TInt completeRate2 = 4800;
+	TMockLtsyData2 <TInfoName, TInt > ltsyData2(contextId2, completeRate2);
+	ltsyData2.SerialiseL(data2);
+	
+	// send first request	
+	packetContext.NotifyConnectionSpeedChange(requestStatus, rate);
+	
+	// send second request	
+	packetContext2.NotifyConnectionSpeedChange(requestStatus2, rate2);
+	
+	// sent first completion
+	iMockLTSY.CompleteL (EPacketContextNotifyConnectionSpeedChange, KErrNone, data);
+	
+	// sent second completion
+	iMockLTSY.CompleteL (EPacketContextNotifyConnectionSpeedChange, KErrNone, data2);	
+	
+	// wait for first answer
+	User::WaitForRequest(requestStatus);
+		
+	// wait for second answer
+	User::WaitForRequest(requestStatus2);
+	
+	AssertMockLtsyStatusL();		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+	ASSERT_EQUALS(completeRate, (TInt)rate);
+	ASSERT_EQUALS(completeRate2, (TInt)rate2);
+	
+	CleanupStack::PopAndDestroy(9, this); //packetContext2, packetContext, packetService2, packetService, phone2, telServer2, data,data2 this
+
+	}
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCDL-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Delete
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Delete
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestDelete0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+		
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;	
+	packetContext.OpenNewContext(packetService, contextId);	
+	CleanupClosePushL(packetContext);
+	
+	
+	//-------------------------------------------------------------------------
+	// SEND Delete request when ContextStatus is Unknown
+ 	//-------------------------------------------------------------------------
+	TRequestStatus requestStatus;	
+	packetContext.Delete(requestStatus);
+	
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrNotReady, requestStatus.Int());	
+	AssertMockLtsyStatusL();
+	
+	
+ 	// Set context in Active state
+ 	SetContextActiveL(contextId);
+	
+	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::Delete
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+ 	TMockLtsyData1 <TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+	TRequestStatus mockLtsyStatus;
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	// send completion 
+	iMockLTSY.CompleteL(EPacketContextDelete, KErrNone, data);
+	// wait for completion
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	AssertMockLtsyStatusL();
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A: failure to dispatch request to LTSY
+ 	//-------------------------------------------------------------------------
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	iMockLTSY.ExpectL(EPacketContextDelete, expectData, KErrNotSupported);
+
+	packetContext.Delete(requestStatus);
+	
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	
+	AssertMockLtsyStatusL();
+	
+	//-------------------------------------------------------------------------
+	// TEST B: failure on completion of pending request from LTSY->CTSY
+ 	//-------------------------------------------------------------------------
+	iMockLTSY.ExpectL (EPacketContextDelete, expectData);
+	iMockLTSY.CompleteL(EPacketContextDelete, KErrGeneral, data);
+
+	packetContext.Delete(requestStatus);
+	
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());	
+	AssertMockLtsyStatusL();
+
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::Delete when result is not cached.
+ 	//-------------------------------------------------------------------------
+	iMockLTSY.ExpectL (EPacketContextDelete, expectData);
+	iMockLTSY.CompleteL(EPacketContextDelete, KErrNone, data);
+
+	packetContext.Delete(requestStatus);
+		
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+	AssertMockLtsyStatusL();
+
+ 	//-------------------------------------------------------------------------
+	// TEST D: failure to modify context parameters when context deleted
+ 	//-------------------------------------------------------------------------
+	packetContext.ModifyActiveContext(requestStatus);
+	User::WaitForRequest(requestStatus);		
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotReady, requestStatus.Int());
+
+	CleanupStack::PopAndDestroy(5, this); //packetContext, packetService, expectData, data, this	
+	}
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCDL-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::Delete
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::Delete
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestDelete0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);	
+	
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RBuf8 expectData2;
+	CleanupClosePushL(expectData2);
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+	
+	// Set first context in Active state
+ 	SetContextActiveL(contextId);
+ 	
+ 	// Set second context in Active state
+ 	SetContextActiveL(contextId2);
+
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::Delete
+ 	//-------------------------------------------------------------------------
+	
+ 	// data for first CompleteL
+ 	TMockLtsyData1 <TInfoName > ltsyData(contextId);
+	ltsyData.SerialiseL(data);
+ 	
+	// data for second CompleteL
+ 	TMockLtsyData1 <TInfoName > ltsyData2(contextId2);
+	ltsyData2.SerialiseL(data2);	
+	
+	// for the first request
+	TRequestStatus requestStatus;
+	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	// for the second request
+	TRequestStatus requestStatus2;
+	TMockLtsyData1 <TInfoName> expData2(contextId2);
+	expData2.SerialiseL(expectData2);
+	
+		
+	iMockLTSY.ExpectL(EPacketContextDelete, expectData);	 	
+ 	iMockLTSY.CompleteL(EPacketContextDelete, KErrNone, data);
+	iMockLTSY.ExpectL(EPacketContextDelete, expectData2); 	 
+	iMockLTSY.CompleteL(EPacketContextDelete, KErrNone, data2);
+	
+	// send first request
+	packetContext.Delete(requestStatus);		
+	
+	// send second request
+	packetContext2.Delete(requestStatus2);
+	
+	// wait for first answer
+	User::WaitForRequest(requestStatus);		
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+		
+	// wait for second answer
+	User::WaitForRequest(requestStatus2);		
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(2); // expectData2, expectData
+	CleanupStack::PopAndDestroy(9, this); //packetContext2, packetContext, packetService2, packetService, phone2, telServer2, data,data2 this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCDL-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Delete with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Delete and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestDelete0005L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;	
+	packetContext.OpenNewContext(packetService, contextId);	
+	CleanupClosePushL(packetContext);
+	
+	// Set context in Active state
+ 	SetContextActiveL(contextId);
+	
+	//-------------------------------------------------------------------------
+	// Test A: Test timeout of RPacketContext::Delete
+ 	//------------------------------------------------------------------------- 	
+ 	TRequestStatus requestStatus; 	
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	iMockLTSY.ExpectL (EPacketContextDelete, expectData);
+
+	packetContext.Delete(requestStatus);
+		
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());	
+	AssertMockLtsyStatusL();
+	 	
+	CleanupStack::PopAndDestroy(5, this); //packetContext, packetService, data, expectData, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCA-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Activate
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Activate
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestActivate0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);	
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+		
+ 	//-------------------------------------------------------------------------
+	// TEST A: failure to dispatch request to LTSY
+ 	//-------------------------------------------------------------------------
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	TRequestStatus requestStatus;
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData, KErrNotSupported);
+	
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+	//-------------------------------------------------------------------------
+	// TEST B: failure on completion of pending request from LTSY->CTSY
+ 	//-------------------------------------------------------------------------
+	RPacketContext::TContextConfigGPRS contextConfig;
+	TMockLtsyData2< TInfoName, RPacketContext::TContextConfigGPRS > ltsyData1(contextId, contextConfig);
+	ltsyData1.SerialiseL(data);
+	
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData);
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrGeneral, data);
+	
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::Activate when result is not cached.
+ 	//-------------------------------------------------------------------------
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData);
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data);
+		
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+ 
+ 	//-------------------------------------------------------------------------
+	// TEST E: Unsolicited completion of RPacketContext::Activate
+	// from LTSY.
+ 	//-------------------------------------------------------------------------
+	TRequestStatus mockLtsyStatus;
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	AssertMockLtsyStatusL();
+
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(3, this); // expectData, data, this
+	
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCA-0001b
+@SYMComponent  telephony_ctsy
+
+@SYMDEF DEF126915
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Activate with R99/R4 params
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Activate with R99/R4 context config params
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestActivate0001bL()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);	
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+	
+
+	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::Activate, using TContextConfigR99_R4, when result is 
+	// not cached.
+ 	//-------------------------------------------------------------------------
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	TRequestStatus requestStatus;
+	
+	RPacketContext::TContextConfigR99_R4 contextConfig;
+	TMockLtsyData2< TInfoName, RPacketContext::TContextConfigR99_R4 > ltsyData1(contextId, contextConfig);
+	ltsyData1.SerialiseL(data);
+	
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData);
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data);
+	
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+	
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(3, this); // expectData, data, this
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCA-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::Activate
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::Activate
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestActivate0002L()
+	{
+
+// This test should test cancellation of Activate
+// If this API does not have a cancel, the test step should be completely removed.
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);	
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+	
+		
+ 	//-------------------------------------------------------------------------
+	// Test cancelling of RPacketContext::Activate
+ 	//------------------------------------------------------------------------- 
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+ 
+   	TRequestStatus	requestStatus;	
+ 	RPacketContext::TContextConfigGPRS contextConfig;
+	TMockLtsyData2< TInfoName, RPacketContext::TContextConfigGPRS > ltsyData1(contextId, contextConfig);
+	ltsyData1.SerialiseL(data);
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData);
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data, 10);
+	
+	packetContext.Activate(requestStatus);
+	packetContext.CancelAsyncRequest(EPacketContextActivate);
+	
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	// TSY has started a request and it is not possible to then cancel 
+    // this request. The best thing for the TSY to do in this case is to
+    // proceed as though the Cancel never happened.
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	
+	CleanupStack::PopAndDestroy(2); // packetContext, packetService
+	CleanupStack::PopAndDestroy(3); //  this, expectData, data	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCA-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Activate with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Activate with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestActivate0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// -----------------------------------------------------------------------
+	// call Activate without initialisation of the context
+	// -----------------------------------------------------------------------
+	TRequestStatus	requestStatus;
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrArgument, requestStatus.Int()); 	
+ 	
+	CleanupStack::PopAndDestroy(3, this); //packetContext, packetService, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCA-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::Activate
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::Activate
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestActivate0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RBuf8 data2;
+	CleanupClosePushL(data2);
+	
+	RBuf8 expectData2;
+	CleanupClosePushL(expectData2);
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(telServer2,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	// Open PacketService for the first client
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	// Open PacketService for the second client
+	RPacketService packetService2;
+	packetService2.Open(phone2);
+	CleanupClosePushL(packetService2);
+
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// initialisation of the first context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+	
+	// initialisation of the second context 
+	status = InitContextL(packetContext2, contextId2);
+	ASSERT_EQUALS(KErrNone, status);
+			
+ 	// data for ExpectL for first client
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	// data for CompleteL for first client
+	RPacketContext::TContextConfigGPRS contextConfig;
+	TMockLtsyData2< TInfoName, RPacketContext::TContextConfigGPRS > ltsyData1(contextId, contextConfig);
+	ltsyData1.SerialiseL(data);	
+	
+	// data for ExpectL for second client
+ 	TMockLtsyData1 <TInfoName> expData2(contextId2);
+	expData2.SerialiseL(expectData2);
+	
+	// data for CompleteL for second client
+	RPacketContext::TContextConfigGPRS contextConfig2;
+	TMockLtsyData2< TInfoName, RPacketContext::TContextConfigGPRS > ltsyData2(contextId2, contextConfig2);
+	ltsyData2.SerialiseL(data2);
+	
+	// first request
+	TRequestStatus	requestStatus;
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData);
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data);		
+	packetContext.Activate(requestStatus);
+	
+	// second request
+	TRequestStatus	requestStatus2;
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData2);
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data2);		
+	packetContext2.Activate(requestStatus2);	
+	
+	// wait for first answer
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());		
+	
+	// wait for the second answer
+	User::WaitForRequest(requestStatus2);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int());		
+	
+	CleanupStack::PopAndDestroy(11, this); // ... phone2, telServer2, expectData, data, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCA-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::Activate with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Activate and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestActivate0005L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);		
+ 
+	//-------------------------------------------------------------------------
+	// Test A: Test timeout of RPacketContext::Activate
+ 	//-------------------------------------------------------------------------
+ 	TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+ 	iMockLTSY.ExpectL(EPacketContextActivate, expectData);
+ 	
+ 	TRequestStatus	requestStatus;
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); 	
+
+	CleanupStack::PopAndDestroy(5, this); // data, expectData, packetContext, packetService, this
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetConfig
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetConfig
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetConfig0001L()
+	{
+
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+		
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);				
+ 	
+ 	//-------------------------------------------------------------------------
+	// TEST C1: Successful completion request of
+	// RPacketContext::GetConfig with  RPacketContext::TContextConfigGPRS param
+ 	//-------------------------------------------------------------------------
+	TRequestStatus	requestStatus;
+	RPacketContext::TContextConfigGPRS contextConfig;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig); 
+	
+	packetContext.GetConfig(requestStatus, pckgConfig);
+	
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int()); 	
+	TBuf8<50> null50; 	
+	TBuf8<252> nullName; 
+	ASSERT_EQUALS(nullName, 					contextConfig.iAccessPointName);
+	ASSERT_EQUALS(RPacketContext::ENotRequired, contextConfig.iAnonymousAccessReqd);
+	ASSERT_EQUALS(0, 							contextConfig.iNWIContext);
+	ASSERT_EQUALS(null50, 						contextConfig.iPdpAddress );
+	ASSERT_EQUALS((TUint)0,						contextConfig.iPdpCompression);
+	ASSERT_EQUALS(RPacketContext::EPdpTypeIPv4, contextConfig.iPdpType );	
+	ASSERT_EQUALS(0, 							contextConfig.iUseEdge);			
+	ASSERT_EQUALS(RPacketContext::EProtocolNone,contextConfig.iProtocolConfigOption.iAuthInfo.iProtocol);	
+	ASSERT_EQUALS(null50, 		contextConfig.iProtocolConfigOption.iAuthInfo.iUsername);
+	ASSERT_EQUALS(null50, 		contextConfig.iProtocolConfigOption.iAuthInfo.iPassword);
+	ASSERT_EQUALS(null50,		contextConfig.iProtocolConfigOption.iChallenge);
+	ASSERT_EQUALS(null50, 		contextConfig.iProtocolConfigOption.iResponse);	
+	ASSERT_EQUALS((TUint8)0, 	contextConfig.iProtocolConfigOption.iId);
+	ASSERT_EQUALS(null50, 		contextConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(null50, 		contextConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);
+	
+	
+	//-------------------------------------------------------------------------
+	// TEST C2: Successful completion request of
+	// RPacketContext::GetConfig with  RPacketContext::TContextConfigR99_R4 param
+ 	//-------------------------------------------------------------------------
+	RPacketContext::TContextConfigR99_R4 contextConfig2;
+	TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig2(contextConfig2); 
+	
+	packetContext.GetConfig(requestStatus, pckgConfig2);
+	
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();			
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int()); 		
+	ASSERT_EQUALS(nullName, 					contextConfig2.iAccessPointName);
+	ASSERT_EQUALS(0, 							contextConfig2.iNWIContext);
+	ASSERT_EQUALS(RPacketContext::EBestEffort, 	contextConfig2.iPFI);
+	ASSERT_EQUALS(null50, 						contextConfig2.iPdpAddress);
+	ASSERT_EQUALS(RPacketContext::EPdpTypeIPv4, contextConfig2.iPdpType );
+	ASSERT_EQUALS(0, 							contextConfig2.iUseEdge);
+	ASSERT_EQUALS(RPacketContext::EProtocolNone,contextConfig2.iProtocolConfigOption.iAuthInfo.iProtocol);	
+	ASSERT_EQUALS(null50, 		contextConfig2.iProtocolConfigOption.iAuthInfo.iUsername);
+	ASSERT_EQUALS(null50, 		contextConfig2.iProtocolConfigOption.iAuthInfo.iPassword);
+	ASSERT_EQUALS(null50, 		contextConfig2.iProtocolConfigOption.iChallenge);
+	ASSERT_EQUALS(null50, 		contextConfig2.iProtocolConfigOption.iResponse);	
+	ASSERT_EQUALS((TUint8)0, 	contextConfig2.iProtocolConfigOption.iId);
+	ASSERT_EQUALS(null50, 		contextConfig2.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(null50, 		contextConfig2.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);
+	
+	//-------------------------------------------------------------------------
+	// TEST D: RPacketContext::GetConfig again, this time CTSY
+	// will get result from the cache.
+ 	//-------------------------------------------------------------------------
+ 	
+ 	// initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);		
+ 
+	//value to Config...
+	RPacketContext::TContextConfigGPRS setConfig;       
+    _LIT(KPointName, "Some Name");
+    setConfig.iAccessPointName.Copy(KPointName);
+	setConfig.iAnonymousAccessReqd = RPacketContext::ERequired;
+	setConfig.iNWIContext = ETrue;	
+	_LIT(KPdpAdd, "Some Add");
+    setConfig.iPdpAddress.Copy(KPdpAdd);	
+	setConfig.iPdpCompression = RPacketContext::KPdpDataCompression;	
+	setConfig.iPdpType = RPacketContext::EPdpTypeIPv6;	
+	setConfig.iUseEdge = ETrue;		
+	setConfig.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	_LIT(KUsername, "Some Username");
+	setConfig.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	_LIT(KPassword, "Some Password");
+	setConfig.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	_LIT(KChallenge, "Challenge");
+	setConfig.iProtocolConfigOption.iChallenge.Copy(KChallenge);
+	_LIT(KResponse, "Response");
+	setConfig.iProtocolConfigOption.iResponse.Copy(KResponse);
+	setConfig.iProtocolConfigOption.iId = 10;
+	_LIT(KPrimaryDns, "Some PrimaryDns");
+	setConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	_LIT(KSecondaryDns, "Some SecondaryDns");
+	setConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);	
+	TPckg<RPacketContext::TContextConfigGPRS> pckgSet(setConfig);
+	
+	// Set new value to Config
+	TMockLtsyData1<TInfoName > contexName(contextId);
+    contexName.SerialiseL(data);    
+    TMockLtsyData2<RPacketContext::TContextConfigGPRS, TInfoName > expExpect(setConfig, contextId);
+    expExpect.SerialiseL(expectData);    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data);    
+    packetContext.SetConfig(requestStatus, pckgSet);
+    User::WaitForRequest(requestStatus);
+    ASSERT_EQUALS(KErrNone, requestStatus.Int());    
+    
+    // Get new values
+    packetContext.GetConfig(requestStatus, pckgConfig);
+	
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+	ASSERT_EQUALS(setConfig.iAccessPointName, 		contextConfig.iAccessPointName);
+	ASSERT_EQUALS(setConfig.iAnonymousAccessReqd, 	contextConfig.iAnonymousAccessReqd);
+	ASSERT_EQUALS(setConfig.iNWIContext, 			contextConfig.iNWIContext);
+	ASSERT_EQUALS(setConfig.iPdpAddress, 			contextConfig.iPdpAddress );
+	ASSERT_EQUALS(setConfig.iPdpCompression, 		contextConfig.iPdpCompression);
+	ASSERT_EQUALS(setConfig.iPdpType,				contextConfig.iPdpType );	
+	ASSERT_EQUALS(setConfig.iUseEdge, 				contextConfig.iUseEdge);			
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iAuthInfo.iProtocol,			contextConfig.iProtocolConfigOption.iAuthInfo.iProtocol);	
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iAuthInfo.iUsername, 			contextConfig.iProtocolConfigOption.iAuthInfo.iUsername);
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iAuthInfo.iPassword, 			contextConfig.iProtocolConfigOption.iAuthInfo.iPassword);
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iChallenge, 					contextConfig.iProtocolConfigOption.iChallenge);
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iResponse, 					contextConfig.iProtocolConfigOption.iResponse);	
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iId, 						 	contextConfig.iProtocolConfigOption.iId);
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, 	contextConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(setConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, 	contextConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);	
+	
+	CleanupStack::PopAndDestroy(5, this); // expectData, data, packetContext, packetService, this	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGC-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetConfig with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetConfig with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetConfig0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+		
+	// Open new context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+
+	//-------------------------------------------------------------------------
+	// Test A: Test passing wrong version of parameters to
+	// RPacketContext::GetConfig
+ 	//-------------------------------------------------------------------------
+	TRequestStatus	requestStatus;
+	RPacketContext::TContextConfigCDMA contextConfig;
+	TPckg<RPacketContext::TContextConfigCDMA> pckgConfig(contextConfig); 
+	
+	packetContext.GetConfig(requestStatus, pckgConfig);
+	
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); 	
+	AssertMockLtsyStatusL();
+
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::GetConfig
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::GetConfig
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetConfig0004L()
+	{
+					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	// Open second client
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+
+	RMobilePhone phone2;
+	ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);
+	
+	// Open first context
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	// Open second context
+	TInfoName contextId2;	
+	RPacketContext packetContext2;
+	packetContext2.OpenNewContext(packetService2, contextId2);
+	CleanupClosePushL(packetContext2);
+	//-------------------------------------------------------------------------
+	// Test A: Test multiple clients requesting RPacketContext::GetConfig
+ 	//-------------------------------------------------------------------------
+	
+	TRequestStatus	requestStatus;
+	RPacketContext::TContextConfigGPRS contextConfig;
+	TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig); 
+	
+	TRequestStatus	requestStatus2;
+	RPacketContext::TContextConfigR99_R4 contextConfig2;
+	TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig2(contextConfig2); 
+	
+	// send first request
+	packetContext.GetConfig(requestStatus, pckgConfig);
+	// send second request
+	packetContext2.GetConfig(requestStatus2, pckgConfig2);
+	
+	// wait for the first answer
+	User::WaitForRequest(requestStatus);	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int()); 	
+	TBuf8<50> null50; 	
+	TBuf8<252> nullName; 
+	ASSERT_EQUALS(nullName, contextConfig.iAccessPointName);
+	ASSERT_EQUALS(RPacketContext::ENotRequired, contextConfig.iAnonymousAccessReqd);
+	ASSERT_EQUALS(0, contextConfig.iNWIContext);
+	ASSERT_EQUALS(null50, contextConfig.iPdpAddress );
+	ASSERT_EQUALS((TUint)0, contextConfig.iPdpCompression);
+	ASSERT_EQUALS(RPacketContext::EPdpTypeIPv4, contextConfig.iPdpType );	
+	ASSERT_EQUALS(0, contextConfig.iUseEdge);			
+	ASSERT_EQUALS(RPacketContext::EProtocolNone, contextConfig.iProtocolConfigOption.iAuthInfo.iProtocol);	
+	ASSERT_EQUALS(null50, contextConfig.iProtocolConfigOption.iAuthInfo.iUsername);
+	ASSERT_EQUALS(null50, contextConfig.iProtocolConfigOption.iAuthInfo.iPassword);
+	ASSERT_EQUALS(null50, contextConfig.iProtocolConfigOption.iChallenge);
+	ASSERT_EQUALS(null50, contextConfig.iProtocolConfigOption.iResponse);	
+	ASSERT_EQUALS((TUint8)0, contextConfig.iProtocolConfigOption.iId);
+	ASSERT_EQUALS(null50, contextConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(null50, contextConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);
+	
+	// wait for the second answer
+	User::WaitForRequest(requestStatus2);
+	AssertMockLtsyStatusL();	
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int()); 		
+	ASSERT_EQUALS(nullName, contextConfig2.iAccessPointName);
+	ASSERT_EQUALS(0, contextConfig2.iNWIContext);
+	ASSERT_EQUALS(RPacketContext::EBestEffort, contextConfig2.iPFI);
+	ASSERT_EQUALS(null50, contextConfig2.iPdpAddress);
+	ASSERT_EQUALS(RPacketContext::EPdpTypeIPv4, contextConfig2.iPdpType );
+	ASSERT_EQUALS(0, contextConfig2.iUseEdge);
+	ASSERT_EQUALS(RPacketContext::EProtocolNone, contextConfig2.iProtocolConfigOption.iAuthInfo.iProtocol);	
+	ASSERT_EQUALS(null50, contextConfig2.iProtocolConfigOption.iAuthInfo.iUsername);
+	ASSERT_EQUALS(null50, contextConfig2.iProtocolConfigOption.iAuthInfo.iPassword);
+	ASSERT_EQUALS(null50, contextConfig2.iProtocolConfigOption.iChallenge);
+	ASSERT_EQUALS(null50, contextConfig2.iProtocolConfigOption.iResponse);	
+	ASSERT_EQUALS((TUint8)0, contextConfig2.iProtocolConfigOption.iId);
+	ASSERT_EQUALS(null50, contextConfig2.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);
+	ASSERT_EQUALS(null50, contextConfig2.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);
+	
+	CleanupStack::PopAndDestroy(7, this); //packetContext2, packetContext, packetService2, packetService, phone2, telServer2, this
+	}
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGS-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetStatus
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetStatus
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetStatus0001L()
+    {
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+
+    
+    RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+
+    // test 1: context not inited
+    RPacketContext::TContextStatus contextStatus;    
+    packetContext.GetStatus(contextStatus);
+    ASSERT_EQUALS(RPacketContext::EStatusUnknown, contextStatus);
+    
+    // initialisation of the context 
+	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+		
+    // test2: context inited
+    packetContext.GetStatus(contextStatus);
+    ASSERT_EQUALS(RPacketContext::EStatusInactive, contextStatus);
+    
+
+    AssertMockLtsyStatusL();
+    CleanupStack::PopAndDestroy(2); //packetContext, packetService
+    CleanupStack::PopAndDestroy(2, this); // data, this 
+    }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGS-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::GetStatus
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::GetStatus
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+/*void CCTsyPacketContextFU::TestGetStatus0002L()
+    {
+
+// This test should test cancellation of GetStatus
+// If this API does not have a cancel, the test step should be completely removed.
+
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    TRequestStatus mockLtsyStatus;
+    iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+
+    //-------------------------------------------------------------------------
+    // Test cancelling of RPacketContext::GetStatus
+    //-------------------------------------------------------------------------
+    
+    // Remove the test above if this is not relevant for this API
+
+    // Wait for completion of iMockLTSY.NotifyTerminated
+    // User::WaitForRequest(mockLtsyStatus);
+    CleanupStack::PopAndDestroy(2); // data, this
+    
+    }*/
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGS-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetStatus with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetStatus with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+/*void CCTsyPacketContextFU::TestGetStatus0003L()
+    {
+
+// This test should test sending bad parameter data for GetStatus
+// If this API does not have any parameters, then remove this test completely.
+
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+
+    //-------------------------------------------------------------------------
+    // Test A: Test passing wrong version of parameters to
+    // RPacketContext::GetStatus
+    //-------------------------------------------------------------------------
+
+    // Remove the test above if it is not relevant for this API
+
+    //-------------------------------------------------------------------------
+    // Test B: Test passing wrong descriptor size to parameter in
+    // RPacketContext::GetStatus
+    //-------------------------------------------------------------------------
+
+    // Remove the test above if it is not relevant for this API
+    
+    //-------------------------------------------------------------------------
+    // Test C: Test passing out of bounds parameters to
+    // RPacketContext::GetStatus
+    //-------------------------------------------------------------------------
+    
+    // Remove the test above if it is not relevant for this API
+
+    // Done !
+    CleanupStack::PopAndDestroy(2, this); // data, this
+
+    }*/
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGS-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::GetStatus
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::GetStatus
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+/*void CCTsyPacketContextFU::TestGetStatus0004L()
+    {
+
+                    
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+
+    // Open second client
+    RTelServer telServer2;
+    TInt ret = telServer2.Connect();
+    ASSERT_EQUALS(KErrNone, ret);
+    CleanupClosePushL(telServer2);
+
+    RMobilePhone phone2;
+    ret = phone2.Open(iTelServer,KMmTsyPhoneName);
+    ASSERT_EQUALS(KErrNone, ret);
+    CleanupClosePushL(phone2);
+
+    //-------------------------------------------------------------------------
+    // Test A: Test multiple clients requesting RPacketContext::GetStatus
+    //-------------------------------------------------------------------------
+
+    // If this API is flow controlled by Etel or if this API is
+    // synchronous, remove this test completely.
+
+    // To write this test:
+    // If this API has parameters which have different versions, then each
+    // client in this test should use a different version of parameter.
+    // Otherwise, they should use the same version.
+    // All versions of parameters should be used. i.e. If there are three
+    // versions of a parameter, there should be three clients, one using
+    // each one. If the parameter does not have different versions, use
+    // two clients each using the same version.
+
+
+    // Done !
+    CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this
+
+    }*/
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGS-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetStatus with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetStatus and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+/*void CCTsyPacketContextFU::TestGetStatus0005L()
+    {
+
+
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+
+    //-------------------------------------------------------------------------
+    // Test A: Test timeout of RPacketContext::GetStatus
+    //-------------------------------------------------------------------------
+
+    // If this API does not have a timeout, then remove this test completely.
+
+    // Done !
+    CleanupStack::PopAndDestroy(2, this); // data, this
+
+    }*/
+
+ /**
+@SYMTestCaseID BA-CTSY-PKTC-PCSC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::SetConfig
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::SetConfig
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestSetConfig0001L()
+    {
+
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+    
+    RBuf8 expectData;
+    CleanupClosePushL(expectData);
+
+    RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+    
+    // initialisation of the context 
+ 	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);  
+ 
+	// data for SetContext
+    RPacketContext::TContextConfigGPRS setConfig;
+     _LIT(KPointName, "Some Name");
+    setConfig.iAccessPointName.Copy(KPointName);
+	setConfig.iAnonymousAccessReqd = RPacketContext::ERequired;
+	setConfig.iNWIContext = ETrue;	
+	_LIT(KPdpAdd, "Some Add");
+    setConfig.iPdpAddress.Copy(KPdpAdd);	
+	setConfig.iPdpCompression = RPacketContext::KPdpDataCompression;	
+	setConfig.iPdpType = RPacketContext::EPdpTypeIPv6;	
+	setConfig.iUseEdge = ETrue;		
+	setConfig.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	_LIT(KUsername, "Some Username");
+	setConfig.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);
+	_LIT(KPassword, "Some Password");
+	setConfig.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);
+	_LIT(KChallenge, "Challenge");
+	setConfig.iProtocolConfigOption.iChallenge.Copy(KChallenge);
+	_LIT(KResponse, "Response");
+	setConfig.iProtocolConfigOption.iResponse.Copy(KResponse);
+	setConfig.iProtocolConfigOption.iId = 10;
+	_LIT(KPrimaryDns, "Some PrimaryDns");
+	setConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);
+	_LIT(KSecondaryDns, "Some SecondaryDns");
+	setConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);    
+    TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(setConfig);    
+    
+    TRequestStatus requestStatus;    
+
+    //-------------------------------------------------------------------------
+    // TEST A: failure to dispatch request to LTSY
+    //-------------------------------------------------------------------------
+	TMockLtsyData2<RPacketContext::TContextConfigGPRS, TInfoName > expExpect(setConfig, contextId);
+    expExpect.SerialiseL(expectData);
+    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData, KErrNotSupported);
+
+    packetContext.SetConfig(requestStatus, pckgConfig);
+    User::WaitForRequest(requestStatus);
+    AssertMockLtsyStatusL();
+    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+
+    //-------------------------------------------------------------------------
+    // TEST B: failure on completion of pending request from LTSY->CTSY
+    //-------------------------------------------------------------------------
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+
+    TMockLtsyData1<TInfoName > contexName(contextId);
+    contexName.SerialiseL(data);
+    
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrGeneral, data);
+    packetContext.SetConfig(requestStatus, pckgConfig);
+    User::WaitForRequest(requestStatus);
+    AssertMockLtsyStatusL();
+    ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+
+    //-------------------------------------------------------------------------
+    // TEST C: Successful completion request of
+    // RPacketContext::SetConfig when result is not cached.
+    //-------------------------------------------------------------------------
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data);
+
+    packetContext.SetConfig(requestStatus, pckgConfig);
+
+    User::WaitForRequest(requestStatus);
+    AssertMockLtsyStatusL();
+    ASSERT_EQUALS(KErrNone, requestStatus.Int());  
+       
+    //--------------------------------------------
+    // Successful completion for R99 
+    //--------------------------------------------     
+    RPacketContext::TContextConfigR99_R4 setConfig99;    
+     _LIT(KPointName99, "Some Name99");
+    setConfig99.iAccessPointName.Copy(KPointName99);
+	setConfig99.iNWIContext = ETrue;	
+	_LIT(KPdpAdd99, "Some Add99");
+    setConfig99.iPdpAddress.Copy(KPdpAdd99);		
+	setConfig99.iPdpType = RPacketContext::EPdpTypeIPv6;			
+	setConfig99.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;
+	_LIT(KUsername99, "Some Username99");
+	setConfig99.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername99);
+	_LIT(KPassword99, "Some Password99");
+	setConfig99.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword99);
+	_LIT(KChallenge99, "Challenge99");
+	setConfig99.iProtocolConfigOption.iChallenge.Copy(KChallenge99);
+	_LIT(KResponse99, "Response99");
+	setConfig99.iProtocolConfigOption.iResponse.Copy(KResponse99);
+	setConfig99.iProtocolConfigOption.iId = 10;
+	_LIT(KPrimaryDns99, "Some PrimaryDns99");
+	setConfig99.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns99);
+	_LIT(KSecondaryDns99, "Some SecondaryDns99");
+	setConfig99.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns99); 	
+	setConfig99.iPFI = RPacketContext::ESignalling;	   
+    TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig3(setConfig99);    
+
+ 	TMockLtsyData2<RPacketContext::TContextConfigR99_R4, TInfoName > expExpect4(setConfig99, contextId);
+    expectData.Close();
+    expExpect4.SerialiseL(expectData);
+    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data);
+
+    packetContext.SetConfig(requestStatus, pckgConfig3);
+
+    User::WaitForRequest(requestStatus);
+    
+    ASSERT_EQUALS(KErrNone, requestStatus.Int());
+    AssertMockLtsyStatusL();
+    
+    //--------------------------------------------
+    // failure to dispatch request for R99 
+    //--------------------------------------------    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData, KErrNotSupported);
+    //iMockLTSY.CompleteL(EPacketContextSetConfig, KErrGeneral, data);
+
+    packetContext.SetConfig(requestStatus, pckgConfig3);
+
+    User::WaitForRequest(requestStatus);
+    
+    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+    AssertMockLtsyStatusL();
+        
+    //-------------------------------------------------------------------------
+    // TEST E: Unsolicited completion of RPacketContext::SetConfig
+    // from LTSY.
+    //-------------------------------------------------------------------------
+    TRequestStatus mockLtsyStatus;
+    iMockLTSY.NotifyTerminated(mockLtsyStatus);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data, 0);
+    User::WaitForRequest(mockLtsyStatus);        
+    
+    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());  
+
+    AssertMockLtsyStatusL();
+    CleanupStack::PopAndDestroy(2); //packetContext, packetService
+    CleanupStack::PopAndDestroy(3, this); // data, expectData, this    
+    }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCSC-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::SetConfig
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RPacketContext::SetConfig
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestSetConfig0002L()
+    {
+    
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+	RBuf8 data;
+    CleanupClosePushL(data);
+	
+    RBuf8 expectData;
+    CleanupClosePushL(expectData);
+
+    RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+    
+    // initialisation of the context 
+ 	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status); 
+	
+	// data for SetConfig
+    RPacketContext::TContextConfigGPRS contextConfig;
+    _LIT(KPdpAdd, "Some Add");
+    contextConfig.iPdpAddress.Copy(KPdpAdd);
+    TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig);    
+    
+    // data for ExpectL
+    TMockLtsyData2<RPacketContext::TContextConfigGPRS, TInfoName > expExpect(contextConfig, contextId);
+    expExpect.SerialiseL(expectData);
+    
+    //data for CompleteL    
+    TMockLtsyData1<TInfoName > contexName(contextId);
+    contexName.SerialiseL(data);    
+
+    TRequestStatus mockLtsyStatus;
+    iMockLTSY.NotifyTerminated(mockLtsyStatus);
+    
+    TRequestStatus requestStatus;
+    //-------------------------------------------------------------------------
+    // Test cancelling of RPacketContext::SetConfig
+    //-------------------------------------------------------------------------    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data, 20);
+
+    packetContext.SetConfig(requestStatus, pckgConfig);
+	
+    packetContext.CancelAsyncRequest(EPacketContextSetConfig);
+
+    User::WaitForRequest(requestStatus);    
+    AssertMockLtsyStatusL();    
+    // TSY has started a request and it is not possible to then cancel 
+    // this request. (see CMmPacketContextTsy.cpp line 483)
+    ASSERT_EQUALS(KErrNone, requestStatus.Int());    
+
+    // Wait for completion of iMockLTSY.NotifyTerminated
+    User::WaitForRequest(mockLtsyStatus);
+     
+    CleanupStack::PopAndDestroy(2);
+    CleanupStack::PopAndDestroy(3, this); // expectData, data, this    
+    }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCSC-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::SetConfig with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::SetConfig with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestSetConfig0003L()
+    {
+    
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+    
+    RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+    
+    // initialisation of the context 
+	 TInt status = InitContextL(packetContext, contextId);
+	 ASSERT_EQUALS(KErrNone, status);  
+ 
+    //-------------------------------------------------------------------------
+    // Test A: Test passing wrong version of parameters to
+    // RPacketContext::SetConfig
+    //-------------------------------------------------------------------------
+
+    RPacketContext::TContextConfigCDMA contextConfig;
+    TPckg<RPacketContext::TContextConfigCDMA> pckgConfig(contextConfig);    
+
+    TRequestStatus requestStatus;
+        
+    packetContext.SetConfig(requestStatus, pckgConfig);
+
+    User::WaitForRequest(requestStatus);
+    
+    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+    AssertMockLtsyStatusL();
+    
+
+    //------------------------------------------------
+    //set config for context that was not inited, using GPRS
+    //------------------------------------------------
+    TInfoName contextId2;  
+    RPacketContext packetContext2;
+    packetContext2.OpenNewContext(packetService, contextId2);
+    CleanupClosePushL(packetContext2);
+    
+
+    RPacketContext::TContextConfigGPRS contextConfig2;
+    TPckg<RPacketContext::TContextConfigGPRS> pckgConfig2(contextConfig2);    
+    
+    packetContext2.SetConfig(requestStatus, pckgConfig2);
+
+    User::WaitForRequest(requestStatus);
+    
+    ASSERT_EQUALS(KErrNotReady, requestStatus.Int());
+    AssertMockLtsyStatusL();
+    
+
+    //------------------------------------------------
+    //set config for context that was not inited, using R99_R4
+    //------------------------------------------------
+    RPacketContext::TContextConfigR99_R4 contextConfig3;
+    TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig3(contextConfig3);    
+
+    packetContext2.SetConfig(requestStatus, pckgConfig3);
+
+    User::WaitForRequest(requestStatus);
+    
+    ASSERT_EQUALS(KErrNotReady, requestStatus.Int());
+    AssertMockLtsyStatusL();
+
+    CleanupStack::PopAndDestroy(1); //packetContext2
+    
+    CleanupStack::PopAndDestroy(2); //packetContext packetService
+    CleanupStack::PopAndDestroy(2, this); // data, this
+
+    }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCSC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::SetConfig
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::SetConfig
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestSetConfig0004L()
+    {
+    
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+
+    RBuf8 data2;
+    CleanupClosePushL(data2);
+    
+    RBuf8 expectData;
+    CleanupClosePushL(expectData);
+    
+    RBuf8 expectData2;
+    CleanupClosePushL(expectData2);
+
+    // Open second client
+    RTelServer telServer2;
+    TInt ret = telServer2.Connect();
+    ASSERT_EQUALS(KErrNone, ret);
+    CleanupClosePushL(telServer2);
+
+    RMobilePhone phone2;
+    ret = phone2.Open(telServer2,KMmTsyPhoneName);
+    ASSERT_EQUALS(KErrNone, ret);
+    CleanupClosePushL(phone2);
+
+
+    RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+
+    RPacketService packetService2;                
+    ret = packetService2.Open(phone2);
+    ASSERT_EQUALS(KErrNone, ret);
+    CleanupClosePushL(packetService2);
+    
+    // Open first context
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+    
+    // Open second context
+    TInfoName contextId2; 
+    RPacketContext packetContext2;
+    packetContext2.OpenNewContext(packetService2, contextId2);
+    CleanupClosePushL(packetContext2);
+
+
+    // initialisation of the first context 
+ 	TInt status = InitContextL(packetContext, contextId);
+ 	ASSERT_EQUALS(KErrNone, status);
+  
+ 	// initialisation of the second context 
+	 status = InitContextL(packetContext2, contextId2);
+ 	ASSERT_EQUALS(KErrNone, status);
+    
+    TRequestStatus mockLtsyStatus;
+    iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+
+    //-------------------------------------------------------------------------
+    // Test A: Test multiple clients requesting RPacketContext::SetConfig
+    //-------------------------------------------------------------------------    
+    RPacketContext::TContextConfigGPRS contextConfig;
+    _LIT(KPdpAdd, "Some Add");
+    contextConfig.iPdpAddress.Copy(KPdpAdd);
+    TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig);
+    // for the first ExpectL    
+    TMockLtsyData2<RPacketContext::TContextConfigGPRS, TInfoName > expExpect(contextConfig, contextId);
+    expExpect.SerialiseL(expectData);
+    
+    RPacketContext::TContextConfigR99_R4 contextConfig2;
+    TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig2(contextConfig2);
+    // for the second ExpectL
+    TMockLtsyData2<RPacketContext::TContextConfigR99_R4, TInfoName > expExpect2(contextConfig2, contextId2);
+    expExpect2.SerialiseL(expectData2);
+    
+    // for the first ComleteL
+    TMockLtsyData1< TInfoName > ltsyData(contextId);
+    ltsyData.SerialiseL(data);
+    
+    // for the second ComleteL
+    TMockLtsyData1< TInfoName > ltsyData2(contextId2);
+    ltsyData2.SerialiseL(data2);    
+
+    TRequestStatus  requestStatus;    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data, 10);
+
+    TRequestStatus  requestStatus2;    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData2);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data2, 10);
+
+    packetContext.SetConfig(requestStatus, pckgConfig);
+    packetContext2.SetConfig(requestStatus2, pckgConfig2);
+    
+    User::WaitForRequest(requestStatus);
+    ASSERT_EQUALS(KErrNone, requestStatus.Int());
+    User::WaitForRequest(requestStatus2);
+    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+    User::WaitForRequest(mockLtsyStatus);
+
+    // packetContext, packetService, packetContext2, packetService2
+    //one2, telServer2, data2,
+    CleanupStack::PopAndDestroy(2); //expectData2, expectData
+    CleanupStack::PopAndDestroy(9, this); // data, this
+
+    }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCSC-0005
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::SetConfig with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::SetConfig and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestSetConfig0005L()
+    {
+    
+    OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+    
+    RBuf8 expectData;
+    CleanupClosePushL(expectData);
+
+    //-------------------------------------------------------------------------
+    // Test A: Test timeout of RPacketContext::SetConfig
+    //-------------------------------------------------------------------------
+
+    RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+    
+    // initialisation of the first context 
+    TInt status = InitContextL(packetContext, contextId);
+    ASSERT_EQUALS(KErrNone, status);
+
+    RPacketContext::TContextConfigGPRS contextConfig;
+    TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig);    
+    TMockLtsyData2<RPacketContext::TContextConfigGPRS, TInfoName > expExpect(contextConfig, contextId);
+    expExpect.SerialiseL(expectData);
+
+    TRequestStatus requestStatus;
+    
+    TMockLtsyData1<TInfoName > contexName(contextId);
+    contexName.SerialiseL(data);
+    
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+    
+    packetContext.SetConfig(requestStatus, pckgConfig);
+
+    User::WaitForRequest(requestStatus);
+    
+    ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
+    AssertMockLtsyStatusL();
+    
+    
+    CleanupStack::PopAndDestroy(2); //packetContext packetService, 
+    CleanupStack::PopAndDestroy(3, this); // data, expectData, this
+
+    }
+
+
+#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGCI-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::GetConnectionInfo
+@SYMTestPriority High
+@SYMTestActions Invokes requests to RPacketContext::GetConnectionInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetConnectionInfo0001L()
+	{					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;	
+    TRequestStatus requestStatus;
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1;
+	RPacketContext::TConnectionInfoV1 respConnectionInfoV1;
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A1: Successful completion of RPacketContext::GetConnectionInfo
+	// request.
+ 	//-------------------------------------------------------------------------
+ 	
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1(reqConnectionInfoV1); 
+	    	
+	//Get connection info
+	packetContext.GetConnectionInfo(requestStatus, pckgReqConnectionInfoV1);	
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int()); 	
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1.ExtensionId());
+	ASSERT_EQUALS((TUint32)0,                                     reqConnectionInfoV1.iValid);
+
+ 	//-------------------------------------------------------------------------
+	// TEST A2: Successful completion of RPacketContext::GetConnectionInfo
+	// request where RPacketContext::TConnectionInfoV1 parameter contains 
+	// valid data.
+ 	//-------------------------------------------------------------------------
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	respConnectionInfoV1.iValid = RPacketContext::KHSDPACategory;
+	respConnectionInfoV1.iHSDPACategory = 5;
+	respConnectionInfoV1.iValid |= RPacketContext::KHSUPACategory;
+	respConnectionInfoV1.iHSUPACategory = 6;	    	
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData(contextId, respConnectionInfoV1);
+	ltsyData.SerialiseL(data);
+	
+	// Change connection information
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+	//Get connection info
+	packetContext.GetConnectionInfo(requestStatus, pckgReqConnectionInfoV1);
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int()); 	
+	ASSERT_EQUALS(respConnectionInfoV1.ExtensionId(),   reqConnectionInfoV1.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,  reqConnectionInfoV1.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1.iHSUPACategory);
+	
+    CleanupStack::PopAndDestroy(4, this); // packetContext, packetService, data, this	
+    }
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGCI-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for canceling RPacketContext::GetConnectionInfo 
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::GetConnectionInfo cancel request
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetConnectionInfo0002L()
+	{					
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;	
+    TRequestStatus requestStatus;
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1;
+	RPacketContext::TConnectionInfoV1 respConnectionInfoV1;
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A1: Cancel RPacketContext::GetConnectionInfo request 
+	// successfully.
+ 	//-------------------------------------------------------------------------
+ 	
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1(reqConnectionInfoV1); 
+	    	
+	//Get connection info
+	packetContext.GetConnectionInfo(requestStatus, pckgReqConnectionInfoV1);
+	
+	//Cancel connection info request
+	packetContext.CancelAsyncRequest(EPacketContextGetConnectionInfo);	
+	
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	
+	//requestStatus should be KErrNone if CTSY completed GetConnectionInfo() 
+	//request before cancel request arrived. requestStatus should be KErrCancel 
+	//if CTSY received cancel request before before GetConnectionInfo() request
+	//was completed.
+	if ( !( requestStatus.Int() == KErrNone ||  
+	        requestStatus.Int() == KErrCancel ) )
+		{
+		//Wrong error value. Check fails here.
+		ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+		}
+	
+    CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this	
+    }
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCGCI-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::GetConnectionInfo
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::GetConnectionInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestGetConnectionInfo0004L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;	
+    TRequestStatus requestStatus1;
+    TRequestStatus requestStatus2;
+    
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1_1;
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1_2;
+	RPacketContext::TConnectionInfoV1 respConnectionInfoV1;
+	
+	//-------------------------------------------------------------------------
+	// TEST A1: Successful completion of RPacketContext::GetConnectionInfo
+	// request.
+ 	//-------------------------------------------------------------------------
+ 	
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1_1(reqConnectionInfoV1_1);
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1_2(reqConnectionInfoV1_2);
+	    	
+	//Get connection info
+	packetContext.GetConnectionInfo(requestStatus1, pckgReqConnectionInfoV1_1);
+	packetContext.GetConnectionInfo(requestStatus2, pckgReqConnectionInfoV1_2);
+		
+	User::WaitForRequest(requestStatus1);
+	User::WaitForRequest(requestStatus2);	
+	AssertMockLtsyStatusL();
+	
+	//Check results
+	ASSERT_EQUALS(KErrNone, requestStatus1.Int()); 	
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1_1.ExtensionId());
+	ASSERT_EQUALS((TUint32)0,                                     reqConnectionInfoV1_1.iValid);
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int()); 	
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1_2.ExtensionId());
+	ASSERT_EQUALS((TUint32)0,                                     reqConnectionInfoV1_2.iValid);
+	
+	//-------------------------------------------------------------------------
+	// TEST A2: Successful completion of RPacketContext::GetConnectionInfo
+	// request where RPacketContext::TConnectionInfoV1 parameter contains 
+	// valid data.
+ 	//-------------------------------------------------------------------------
+ 	
+ 	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	respConnectionInfoV1.iValid = RPacketContext::KHSDPACategory;
+	respConnectionInfoV1.iHSDPACategory = 5;
+	respConnectionInfoV1.iValid |= RPacketContext::KHSUPACategory;
+	respConnectionInfoV1.iHSUPACategory = 6;	    	
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData(contextId, respConnectionInfoV1);
+	ltsyData.SerialiseL(data);
+	
+	// Change connection information
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ 	
+ 	//Get connection info
+	packetContext.GetConnectionInfo(requestStatus1, pckgReqConnectionInfoV1_1);
+	packetContext.GetConnectionInfo(requestStatus2, pckgReqConnectionInfoV1_2);
+	
+	User::WaitForRequest(requestStatus1);
+	User::WaitForRequest(requestStatus2);
+	AssertMockLtsyStatusL();
+	
+	//Check results
+	ASSERT_EQUALS(KErrNone, requestStatus1.Int()); 	
+	ASSERT_EQUALS(respConnectionInfoV1.ExtensionId(),   reqConnectionInfoV1_1.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_1.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,  reqConnectionInfoV1_1.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_1.iHSUPACategory);
+ 	ASSERT_EQUALS(KErrNone, requestStatus2.Int()); 	
+	ASSERT_EQUALS(respConnectionInfoV1.ExtensionId(),   reqConnectionInfoV1_2.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_2.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,  reqConnectionInfoV1_2.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_2.iHSUPACategory);
+	
+	CleanupStack::PopAndDestroy(4, this); // packetContext, packetService, data
+	}
+	
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCIC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::NotifyConnectionInfoChange
+@SYMTestPriority High
+@SYMTestActions Invokes requests to RPacketContext::NotifyConnectionInfoChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConnectionInfoChange0001L()
+	{
+	INFO_PRINTF1(_L("Testing notification of change in TConnectionInfoV1.iValid .."));
+	TestNotifyConnectionInfoChange0001_workerL(ETrue,EFalse,EFalse);
+	INFO_PRINTF1(_L("Testing notification of change in TConnectionInfoV1.iHSDPACategory .."));
+	TestNotifyConnectionInfoChange0001_workerL(EFalse,ETrue,EFalse);
+	INFO_PRINTF1(_L("Testing notification of change in TConnectionInfoV1.iHSUPACategory .."));
+	TestNotifyConnectionInfoChange0001_workerL(EFalse,EFalse,ETrue);
+	INFO_PRINTF1(_L("Testing that no change leads to no notification .."));
+	TestNotifyConnectionInfoChange0001_workerL(ETrue,ETrue,ETrue,ETrue);
+	INFO_PRINTF1(_L(" All ok!"));
+	}
+
+
+void CCTsyPacketContextFU::TestNotifyConnectionInfoChange0001_workerL(TBool aChangeValid,TBool aChangeHSDPACategory,TBool aChangeHSUPACategory,TBool aResendFirst)
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	TInfoName contextId;
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+	
+	TRequestStatus mockLtsyStatus;
+    TRequestStatus requestStatus;
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1;
+	RPacketContext::TConnectionInfoV1 respConnectionInfoV1;
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A1: Successful completion of
+	// RPacketContext::NotifyConnectionInfoChange request.
+ 	//-------------------------------------------------------------------------
+ 	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ 	
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1(reqConnectionInfoV1); 
+	    	
+	//Make NotifyConnectionInfoChange request
+	packetContext.NotifyConnectionInfoChange(requestStatus, pckgReqConnectionInfoV1);
+
+	//Send response via MockLTSY
+	respConnectionInfoV1.iValid = RPacketContext::KHSDPACategory;
+	respConnectionInfoV1.iHSDPACategory = 1;
+	respConnectionInfoV1.iHSUPACategory = 0;
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData1(contextId, respConnectionInfoV1);
+	ltsyData1.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	
+	//NotifyConnectionInfoChange request is completed to test client
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,			reqConnectionInfoV1.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,	reqConnectionInfoV1.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,	reqConnectionInfoV1.iHSUPACategory);
+	
+	
+	// special case to ensure no notification occurs when same data is received twice
+	if(aResendFirst)
+		{
+		iMockLTSY.NotifyTerminated(mockLtsyStatus);
+		iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+		User::WaitForRequest(mockLtsyStatus);
+		ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());		
+		}
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A2: Successful completion of
+	// RPacketContext::NotifyConnectionInfoChange request where
+	// RPacketContext::TConnectionInfoV1 parameter data changes.
+ 	//-------------------------------------------------------------------------
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+	
+	//Make NotifyConnectionInfoChange request
+	packetContext.NotifyConnectionInfoChange(requestStatus, pckgReqConnectionInfoV1);
+	
+	//Send response via MockLTSY
+	respConnectionInfoV1.iValid = aChangeValid ? (RPacketContext::KHSDPACategory | RPacketContext::KHSUPACategory) : RPacketContext::KHSDPACategory ;
+	respConnectionInfoV1.iHSDPACategory = aChangeHSDPACategory ? 5 : 1;
+	respConnectionInfoV1.iHSUPACategory = aChangeHSUPACategory ? 6 : 0;
+	
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData2(contextId, respConnectionInfoV1);
+	data.Close();
+	ltsyData2.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+	//NotifyConnectionInfoChange request is completed to test client
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());
+	ASSERT_EQUALS(respConnectionInfoV1.ExtensionId(),   reqConnectionInfoV1.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,  reqConnectionInfoV1.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1.iHSUPACategory);
+	
+    CleanupStack::PopAndDestroy(4, this); // packetContext, packetService, data, this
+    }
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCIC-0002
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancel RPacketContext::NotifyConnectionInfoChange request
+@SYMTestPriority High
+@SYMTestActions Invokes cancel RPacketContext::NotifyConnectionInfoChange request
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConnectionInfoChange0002L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RBuf8 data;
+	CleanupClosePushL(data);	
+	
+	RPacketService packetService;
+	OpenPacketServiceL(packetService);
+	CleanupClosePushL(packetService);
+	
+	TInfoName contextId;	
+	RPacketContext packetContext;
+	packetContext.OpenNewContext(packetService, contextId);
+	CleanupClosePushL(packetContext);
+		
+	TRequestStatus mockLtsyStatus;	
+    TRequestStatus requestStatus;
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1;
+	RPacketContext::TConnectionInfoV1 respConnectionInfoV1;
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A1: RPacketContext::NotifyConnectionInfoChange request can be
+	// cancelled successfully. 
+ 	//-------------------------------------------------------------------------	
+ 	
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1(reqConnectionInfoV1); 
+	    	
+	//Make NotifyConnectionInfoChange request
+	packetContext.NotifyConnectionInfoChange(requestStatus, pckgReqConnectionInfoV1);
+
+	User::After( 1000 );
+	
+	//Cancel NotifyConnectionInfoChange request	
+	packetContext.CancelAsyncRequest(EPacketContextNotifyConnectionInfoChange);
+	
+	//NotifyConnectionInfoChange request is completed to test client	
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrCancel, requestStatus.Int()); 
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A2: RPacketContext::NotifyConnectionInfoChange request can be
+	// made again after cancelled. 
+ 	//-------------------------------------------------------------------------		
+
+	iMockLTSY.NotifyTerminated(mockLtsyStatus); 	
+	    	
+	//Send response via MockLTSY. Nothing should happen because 
+	//NotifyConnectionInfoChange request has been cancelled.
+	respConnectionInfoV1.iHSDPACategory = 2;
+	respConnectionInfoV1.iHSUPACategory = 3;
+	respConnectionInfoV1.iValid = RPacketContext::KHSDPACategory | RPacketContext::KHSUPACategory;
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData(contextId, respConnectionInfoV1);
+	ltsyData.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);	
+		
+	respConnectionInfoV1.iHSDPACategory = 3;
+	respConnectionInfoV1.iHSUPACategory = 4;
+	respConnectionInfoV1.iValid = RPacketContext::KHSDPACategory | RPacketContext::KHSUPACategory;
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyDat2(contextId, respConnectionInfoV1);
+	ltsyData.SerialiseL(data);
+	
+	//Make NotifyConnectionInfoChange request
+	packetContext.NotifyConnectionInfoChange(requestStatus, pckgReqConnectionInfoV1);
+	
+	//Send response again via MockLTSY	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());		
+	
+	//NotifyConnectionInfoChange request is completed to test client	
+	User::WaitForRequest(requestStatus);	
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus.Int()); 	
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,       			  reqConnectionInfoV1.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,       	  reqConnectionInfoV1.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,       	  reqConnectionInfoV1.iHSUPACategory);	
+
+    CleanupStack::PopAndDestroy(4, this); // packetContext, packetService, data, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCNCIC-0004
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::NotifyConnectionInfoChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RPacketContext::NotifyConnectionInfoChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestNotifyConnectionInfoChange0004L()
+	{	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	//Open new context
+	RPacketService packetService1;
+	OpenPacketServiceL(packetService1);
+	CleanupClosePushL(packetService1);
+	
+	TInfoName contextId;	
+	RPacketContext packetContext1;
+	packetContext1.OpenNewContext(packetService1, contextId);
+	CleanupClosePushL(packetContext1);	
+	
+	// Open second client and existing context
+	RTelServer telServer2;
+	TInt ret = telServer2.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer2);
+	
+	RMobilePhone phone2;
+	ret = phone2.Open(telServer2,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone2);	
+	
+	RPacketService packetService2;                
+	ret = packetService2.Open(phone2);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService2);	
+	
+	RPacketContext packetContext2;
+    ret = packetContext2.OpenExistingContext(packetService2, contextId);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetContext2);    		
+	
+	//Open third client and new context
+	RTelServer telServer3;
+	ret = telServer3.Connect();
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(telServer3);
+	
+	RMobilePhone phone3;
+	ret = phone3.Open(telServer3,KMmTsyPhoneName);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(phone3);	
+	
+	RPacketService packetService3;                
+	ret = packetService3.Open(phone3);
+	ASSERT_EQUALS(KErrNone, ret);
+	CleanupClosePushL(packetService3);	
+	
+	TInfoName contextId2;	
+	RPacketContext packetContext3;
+	packetContext3.OpenNewContext(packetService3, contextId2);
+	CleanupClosePushL(packetContext3);	
+	
+	TRequestStatus mockLtsyStatus;	
+    TRequestStatus requestStatus1;
+    TRequestStatus requestStatus2;
+    TRequestStatus requestStatus3;
+	RPacketContext::TConnectionInfoV1 respConnectionInfoV1;    
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1_1;
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1_1(reqConnectionInfoV1_1); 	
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1_2;
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1_2(reqConnectionInfoV1_2); 	
+	RPacketContext::TConnectionInfoV1 reqConnectionInfoV1_3;
+	TPckg<RPacketContext::TConnectionInfoV1> pckgReqConnectionInfoV1_3(reqConnectionInfoV1_3); 	
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A1: Successful completion of 
+	// RPacketContext::NotifyConnectionInfoChange request for multible clients.
+ 	//-------------------------------------------------------------------------
+ 	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus); 	
+	    	
+	//Make NotifyConnectionInfoChange requests
+	packetContext1.NotifyConnectionInfoChange(requestStatus1, pckgReqConnectionInfoV1_1);
+	packetContext2.NotifyConnectionInfoChange(requestStatus2, pckgReqConnectionInfoV1_2);
+	packetContext3.NotifyConnectionInfoChange(requestStatus3, pckgReqConnectionInfoV1_3);		
+
+	//Send response via MockLTSY to first packet context
+	respConnectionInfoV1.iHSDPACategory = 2;
+	respConnectionInfoV1.iHSUPACategory = 3;
+	respConnectionInfoV1.iValid = RPacketContext::KHSDPACategory | RPacketContext::KHSUPACategory;
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData1(contextId, respConnectionInfoV1);
+	ltsyData1.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	
+	//NotifyConnectionInfoChange request is completed to the test clients 1 & 2
+	User::WaitForRequest(requestStatus1);
+	User::WaitForRequest(requestStatus2);		
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus1.Int()); 	
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1_1.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_1.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,	reqConnectionInfoV1_1.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_1.iHSUPACategory);
+
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int()); 	
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1_2.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_2.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,	reqConnectionInfoV1_2.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_2.iHSUPACategory);
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus); 
+	
+	//Call notification again
+	packetContext1.NotifyConnectionInfoChange(requestStatus1, pckgReqConnectionInfoV1_1);
+	packetContext2.NotifyConnectionInfoChange(requestStatus2, pckgReqConnectionInfoV1_2);	
+
+	//Send response via MockLTSY to second packet context
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData2(contextId2, respConnectionInfoV1);
+	data.Close();
+	ltsyData2.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	
+	//NotifyConnectionInfoChange request is completed to the test client 3
+	User::WaitForRequest(requestStatus3);		
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus3.Int()); 	
+	ASSERT_EQUALS((TInt)TConnectionInfoBase::KConnectionInfoV1,   reqConnectionInfoV1_3.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_3.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,	reqConnectionInfoV1_3.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_3.iHSUPACategory);
+	
+	//Call notification again
+	packetContext3.NotifyConnectionInfoChange(requestStatus3, pckgReqConnectionInfoV1_3);	
+	
+ 	//-------------------------------------------------------------------------
+	// TEST A2: Successful completion of 
+	// RPacketContext::NotifyConnectionInfoChange request for multiple clients. 
+	// RPacketContext::TConnectionInfoV1 parameter data changes.
+ 	//-------------------------------------------------------------------------		
+
+	iMockLTSY.NotifyTerminated(mockLtsyStatus); 		    			
+
+	//Send response via MockLTSY to first packet context	
+	respConnectionInfoV1.iValid = RPacketContext::KHSDPACategory;
+	respConnectionInfoV1.iHSDPACategory = 5;
+	respConnectionInfoV1.iValid |= RPacketContext::KHSUPACategory;
+	respConnectionInfoV1.iHSUPACategory = 6;	    	
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData3(contextId, respConnectionInfoV1);
+	data.Close();	
+	ltsyData3.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+			
+	//NotifyConnectionInfoChange request is completed to the test clients 1 & 2
+	User::WaitForRequest(requestStatus1);
+	User::WaitForRequest(requestStatus2);		
+	AssertMockLtsyStatusL();
+	
+	ASSERT_EQUALS(KErrNone, requestStatus1.Int()); 	
+	ASSERT_EQUALS(respConnectionInfoV1.ExtensionId(),   reqConnectionInfoV1_1.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_1.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,  reqConnectionInfoV1_1.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_1.iHSUPACategory);	
+	
+	ASSERT_EQUALS(KErrNone, requestStatus2.Int()); 	
+	ASSERT_EQUALS(respConnectionInfoV1.ExtensionId(),   reqConnectionInfoV1_2.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_2.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,  reqConnectionInfoV1_2.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_2.iHSUPACategory);
+	
+	iMockLTSY.NotifyTerminated(mockLtsyStatus);
+		
+	//Call notification again
+	packetContext1.NotifyConnectionInfoChange(requestStatus1, pckgReqConnectionInfoV1_1);
+	packetContext2.NotifyConnectionInfoChange(requestStatus2, pckgReqConnectionInfoV1_2);		
+		
+	//Send response via MockLTSY to second packet context
+	TMockLtsyData2< TInfoName, RPacketContext::TConnectionInfoV1 > ltsyData4(contextId2, respConnectionInfoV1);
+	data.Close();	
+	ltsyData4.SerialiseL(data);
+	
+	iMockLTSY.CompleteL(EPacketContextNotifyConnectionInfoChange, KErrNone, data);
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
+	
+	//NotifyConnectionInfoChange request is completed to the test client 3	
+	User::WaitForRequest(requestStatus3);		
+	AssertMockLtsyStatusL();	
+	
+	ASSERT_EQUALS(KErrNone, requestStatus3.Int()); 	
+	ASSERT_EQUALS(respConnectionInfoV1.ExtensionId(),   reqConnectionInfoV1_3.ExtensionId());
+	ASSERT_EQUALS(respConnectionInfoV1.iValid,          reqConnectionInfoV1_3.iValid);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSDPACategory,  reqConnectionInfoV1_3.iHSDPACategory);
+	ASSERT_EQUALS(respConnectionInfoV1.iHSUPACategory,  reqConnectionInfoV1_3.iHSUPACategory);	
+	
+	CleanupStack::PopAndDestroy(12, this); //packetContext3, packetService3, phone3, telServer3,
+									       //packetContext2, packetService2, phone2, telServer2, 
+									       //packetContext1, packetService1, data, this			
+    }
+
+#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONSC-0001
+@SYMDEF DEF125564
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenNewSecondaryContext
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenNewSecondaryContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/    
+void CCTsyPacketContextFU::TestOpenNewSecondaryContext0001L()
+	{
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RBuf8 data;
+	CleanupClosePushL(data);
+	
+	RBuf8 expectData;
+	CleanupClosePushL(expectData);
+
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+    
+    //-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::SetConfig when result is not cached.
+ 	//-------------------------------------------------------------------------
+	TInfoName contextIdSecondary;	
+	RPacketContext packetContextSecondary;
+	TInt err = packetContextSecondary.OpenNewSecondaryContext(packetService, contextId, contextIdSecondary);	
+	ASSERT_EQUALS(KErrNone, err);
+	CleanupClosePushL(packetContextSecondary);
+	
+    //-------------------------------------------------------------------------
+	// Try to Activate SecondaryContext in order to 
+	// call CMmPacketQoSGsmWcdmaExt::ProfileAsked()
+ 	//-------------------------------------------------------------------------
+ 	
+ 	// initialisation of the secondary context 
+	TInt status = InitContextL(packetContextSecondary, contextIdSecondary, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+	AssertMockLtsyStatusL();
+	
+	// create new QoS
+	RBuf profileName;
+	CleanupClosePushL(profileName);
+	RPacketQoS packetQoS;
+	packetQoS.OpenNewQoS(packetContextSecondary, profileName);
+	CleanupClosePushL(packetQoS);
+	
+ 	
+	// try to activate SecondaryContext	in order to call CMmPacketQoSGsmWcdmaExt::ProfileAsked()
+	TRequestStatus requestStatus;
+	packetContextSecondary.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrArgument, requestStatus.Int());
+	AssertMockLtsyStatusL();
+	
+			
+	//-------------------------------------------------------------------------	
+	// Try to open too many contexts
+ 	//-------------------------------------------------------------------------	
+	RPacketContext newPacketContext[KMmMaxNumberOfContexts - 2];
+ 	for (TInt i = 0; i < KMmMaxNumberOfContexts - 2; i++) // -2 -- because there are already 2 contexts
+ 		{ 		
+ 			TInfoName newContextIdSecondary;
+ 			err = newPacketContext[i].OpenNewSecondaryContext(packetService, contextId, newContextIdSecondary);
+ 			ASSERT_EQUALS(KErrNone, err);
+    		CleanupClosePushL(newPacketContext[i]);
+ 		}
+ 		
+ 	RPacketContext OneMorePacketContext;
+ 	TInfoName contextIdSecondary1;
+ 	err = OneMorePacketContext.OpenNewSecondaryContext(packetService, contextId, contextIdSecondary1);
+ 	TInt expectedError = ( KErrOverflow & 0x0000FFFF ) |
+                    	 ( KErrUmtsMaxNumOfContextExceededByPhone << 16 );
+ 	ASSERT_EQUALS(expectedError, err); 	
+	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy( (KMmMaxNumberOfContexts - 2) ); // set of contexts...	
+	CleanupStack::PopAndDestroy(8, this); // this...
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONSC-0001b
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for Activation of RPacketContext::OpenNewSecondaryContext
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::Activate after RPacketContext::RemovePacketFilter for SecondaryContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/    
+void CCTsyPacketContextFU::TestOpenNewSecondaryContext0001bL()
+	{
+	OpenEtelServerL(EUseExtendedError);
+    CleanupStack::PushL(TCleanupItem(Cleanup,this));
+    OpenPhoneL();
+
+    RBuf8 data;
+    CleanupClosePushL(data);
+    
+    RBuf8 expectData;
+    CleanupClosePushL(expectData);
+
+    RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    // Open new primary packet context
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+    
+    // initialisation of the context 
+ 	TInt status = InitContextL(packetContext, contextId);
+	ASSERT_EQUALS(KErrNone, status);  
+ 
+	// data for SetContext
+    RPacketContext::TContextConfigGPRS setConfig;
+     _LIT(KPointName, "Some Name");
+    setConfig.iAccessPointName.Copy(KPointName);
+    TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(setConfig);    
+    
+    TRequestStatus requestStatus;    
+
+    TMockLtsyData2<RPacketContext::TContextConfigGPRS, TInfoName > expExpect(setConfig, contextId);
+    expExpect.SerialiseL(expectData);
+    
+    TMockLtsyData1<TInfoName > contextName(contextId);
+   	contextName.SerialiseL(data);
+ 	  
+    iMockLTSY.ExpectL(EPacketContextSetConfig, expectData);
+    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data);
+
+    packetContext.SetConfig(requestStatus, pckgConfig);
+
+    User::WaitForRequest(requestStatus);
+    AssertMockLtsyStatusL();
+    ASSERT_EQUALS(KErrNone, requestStatus.Int());  
+   
+    TMockLtsyData1 <TInfoName> expData(contextId);
+	expData.SerialiseL(expectData);
+	
+	// Activate this primary context.
+	RPacketContext::TContextConfigGPRS contextConfig;
+	TMockLtsyData2< TInfoName, RPacketContext::TContextConfigGPRS > ltsyData1(contextId, contextConfig);
+	ltsyData1.SerialiseL(data);
+	iMockLTSY.ExpectL(EPacketContextActivate, expectData);
+	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data);
+		
+	packetContext.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	AssertMockLtsyStatusL();
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+    
+   	// Open new secondary context
+	TInfoName contextIdSecondary;	
+	RPacketContext packetContextSecondary;
+	TInt err = packetContextSecondary.OpenNewSecondaryContext(packetService, contextId, contextIdSecondary);
+ 	ASSERT_EQUALS(KErrNone, err);	
+	CleanupClosePushL(packetContextSecondary);
+	
+   	// initialisation of the secondary context 
+	status = InitContextL(packetContextSecondary, contextIdSecondary, contextId);
+	ASSERT_EQUALS(KErrNone, status);
+	AssertMockLtsyStatusL();
+	
+	// Add filter
+	RPacketContext::TPacketFilterV2 filter;
+	filter.iId = 1;
+	RPacketContext::TPacketFilterV2Pckg filterPckg (filter);
+	err = AddContextPacketFilterL(packetContextSecondary, contextIdSecondary,filter);// ETrue means that this request doesn't reache LTSY
+	ASSERT_EQUALS(KErrNone, err);
+	AssertMockLtsyStatusL();	
+	
+	// set context Active
+	SetContextActiveL(contextIdSecondary);
+	AssertMockLtsyStatusL();
+	
+	// Open and set QoS profile
+	RPacketQoS packetQoSSecondary;
+	RPacketQoS::TQoSGPRSRequested secondaryRequested;
+	err = CreateQoSAndSetProfileParamLC(packetQoSSecondary, packetContextSecondary,
+											 contextIdSecondary, secondaryRequested, contextId);// contextId -- is name of "primary" context
+	ASSERT_EQUALS(KErrNone, err);
+	AssertMockLtsyStatusL();
+
+	// Remove the already added packet filter
+	TInt filterId = 1;
+	packetContextSecondary.RemovePacketFilter(requestStatus, filterId);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
+	AssertMockLtsyStatusL();		
+	
+	// Activate the secondary context
+				
+	packetContextSecondary.Activate(requestStatus);
+	User::WaitForRequest(requestStatus);
+	ASSERT_EQUALS(KErrArgument, requestStatus.Int());
+	
+	CleanupStack::PopAndDestroy(7, this);
+	
+	}
+
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONSC-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenNewSecondaryContext with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenNewSecondaryContext with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestOpenNewSecondaryContext0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);     
+      
+    RPacketContext packetContextSecondary;
+ 	TInfoName contextIdSecondary;
+ 	
+    // -----------------------------------------------------------------------
+    // Test with too long ContextId
+    // ----------------------------------------------------------------------    
+    TBuf<KMaxInfoName + 1> longContextId;
+    _LIT(KLongId, "qwertyuiopasdfghj");
+    longContextId.Copy(KLongId);
+	TInt err = packetContextSecondary.OpenNewSecondaryContext(packetService, longContextId, contextIdSecondary);    
+	ASSERT_EQUALS(KErrArgument, err);	
+	//We need to close the sub sessiun before we open a new context 
+	packetContextSecondary.Close();
+	
+ 	
+	
+	// -----------------------------------------------------------------------
+    // Previous OpenNewSecondaryContext failed with KErrArgument
+    // so try OpenNewSecondaryContext with correct params
+    // ----------------------------------------------------------------------     
+	err = packetContextSecondary.OpenNewSecondaryContext(packetService, contextId, contextIdSecondary);    
+	ASSERT_EQUALS(KErrNone, err);         	   
+        
+    AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(3, this); // this, ...
+	}
+	
+	
+	
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONSC-0003b
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenNewSecondaryContext with wrong ContextId
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenNewSecondaryContext with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestOpenNewSecondaryContext0003bL()
+	{	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext); 
+   
+	
+	// -----------------------------------------------------------------------
+    // Test with wrong ContextId
+    // ----------------------------------------------------------------------
+    RPacketContext packetContextSecondary;
+    TInfoName wrongContextId;
+    _LIT(KSameId, "WrongId");
+    wrongContextId.Copy(KSameId);    
+    
+    TInfoName contextIdSecondary;
+    TInt err = packetContextSecondary.OpenNewSecondaryContext(packetService, wrongContextId, contextIdSecondary);
+	CleanupClosePushL(packetContextSecondary);        
+    ASSERT_EQUALS(KErrArgument, err);
+    
+    AssertMockLtsyStatusL();    
+	CleanupStack::PopAndDestroy(4, this); // this, ...
+	}
+	
+	
+	
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONSC-0003c
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenNewSecondaryContext with with empty PacketService
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenNewSecondaryContext with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestOpenNewSecondaryContext0003cL()
+	{	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+		
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+    
+    TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext); 
+	      
+    // -----------------------------------------------------------------------
+    // Test with empty PacketService
+    // -----------------------------------------------------------------------    
+    RPacketService emptyPacketService;
+    RPacketContext packetContextSecondary;
+    TInfoName contextIdSecondary; 
+    // there should be EEtelPanicNullHandle panic 
+    TInt err = packetContextSecondary.OpenNewSecondaryContext(emptyPacketService, contextId, contextIdSecondary);
+    
+    AssertMockLtsyStatusL();    
+	CleanupStack::PopAndDestroy(3, this); // this, ...
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenNewContext
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenNewContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/    
+void CCTsyPacketContextFU::TestOpenNewContext0001L()
+	{
+	
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+		
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);    
+       
+ 	//-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::SetConfig when result is not cached.
+ 	//------------------------------------------------------------------------
+	TInfoName contextId;  
+    RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);
+
+ 	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONC-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenNewContext with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenNewContext with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestOpenNewContext0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+	
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);
+	
+	//-------------------------------------------------------------------------	
+	// Try to open too many contexts
+ 	//-------------------------------------------------------------------------                	
+    TInt err = 0;  	
+ 	for (TInt i = 0; i < KMmMaxNumberOfContexts; i++)
+ 		{
+ 			RPacketContext newPacketContext;
+ 			TInfoName contextId;
+ 			err = newPacketContext.OpenNewContext(packetService, contextId);
+ 			ASSERT_EQUALS(KErrNone, err);
+    		CleanupClosePushL(newPacketContext); 			
+ 		}
+ 		
+ 	RPacketContext OneMorePacketContext;
+ 	TInfoName contextId1;
+ 	err = OneMorePacketContext.OpenNewContext(packetService, contextId1);
+ 	TInt expectedError = ( KErrOverflow & 0x0000FFFF ) |
+                    	 ( KErrUmtsMaxNumOfContextExceededByPhone << 16 );
+ 	ASSERT_EQUALS(expectedError, err); 		
+
+	//-------------------------------------------------------------------------
+	// Use non-created packetService
+ 	//-------------------------------------------------------------------------	
+	RPacketService packetService2;       
+    TInfoName contextId2;
+    RPacketContext packetContext2;
+        
+    // there should be expected EEtelPanicNullHandle panic 
+    packetContext2.OpenNewContext(packetService2, contextId2);  
+      
+	CleanupStack::PopAndDestroy (KErrUmtsMaxNumOfContextExceededByPhone);
+	CleanupStack::PopAndDestroy(2, this); //  packetService1, this
+	}
+
+	
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONEC-0001
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenExistingContext
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenExistingContext
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/    
+void CCTsyPacketContextFU::TestOpenExistingContext0001L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();	
+	
+	RBuf8 data;
+    CleanupClosePushL(data);
+	
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);    
+        
+	TInfoName contextId; 
+	RPacketContext packetContext;
+    packetContext.OpenNewContext(packetService, contextId);
+    CleanupClosePushL(packetContext);   
+          
+    //-------------------------------------------------------------------------
+	// TEST C: Successful completion request of
+	// RPacketContext::SetConfig when result is not cached.
+ 	//-------------------------------------------------------------------------
+ 	RPacketContext packetContext2;
+	TInt err = packetContext2.OpenExistingContext(packetService, contextId);	
+	CleanupClosePushL(packetContext2);
+	ASSERT_EQUALS(KErrNone, err);
+		
+	// -----------------------------------------------------------------------
+    // Test contextId == KStringExternal and iDialUpContext created
+    // ----------------------------------------------------------------------           
+    TRequestStatus	mockLtsyStatus;
+    // Data for CompleteL
+	TInfoName sndName;	
+	TInt sndResult = KErrNotFound;
+	TMockLtsyData2 <TInfoName, TInt > ltsyData(sndName, sndResult);
+	ltsyData.SerialiseL(data);	
+    
+    // ---  create iDialUpContext at first -----------
+	iMockLTSY.NotifyTerminated(mockLtsyStatus); 
+ 	// Issue the Complete...	
+	iMockLTSY.CompleteL(EPacketNotifyContextAdded, KErrNone, data);
+	// wait for completion 
+	User::WaitForRequest(mockLtsyStatus);
+	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+	//------------------------------------------
+	
+	RPacketContext packetContext3;
+    TInfoName longContextId3;
+    _LIT( KStringExternal,  "External"  );
+    longContextId3.Copy(KStringExternal);
+	err = packetContext3.OpenExistingContext(packetService, longContextId3);
+	ASSERT_EQUALS(KErrNone, err);
+	CleanupClosePushL(packetContext3); 		
+		
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(6, this); //packetContext3, packetContext2, packetContext, packetService, data, this
+	}
+
+/**
+@SYMTestCaseID BA-CTSY-PKTC-PCONEC-0003
+@SYMComponent  telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RPacketContext::OpenExistingContext with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RPacketContext::OpenExistingContext with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPacketContextFU::TestOpenExistingContext0003L()
+	{
+	OpenEtelServerL(EUseExtendedError);
+	CleanupStack::PushL(TCleanupItem(Cleanup,this));
+	OpenPhoneL();
+
+	RPacketService packetService;
+    OpenPacketServiceL(packetService);
+    CleanupClosePushL(packetService);    
+        
+	TInfoName contextId;
+	//-------------------------------------------------------------------------
+	// Test with non-existing context
+ 	//------------------------------------------------------------------------- 
+ 	_LIT(KSomeContext, "SomeContext");
+	contextId.Copy(KSomeContext);
+	RPacketContext packetContext1;
+	TInt err = packetContext1.OpenExistingContext(packetService, contextId);
+	ASSERT_EQUALS(KErrNotFound, err);
+	AssertMockLtsyStatusL();	
+	
+	// -----------------------------------------------------------------------
+    // Test with too long ContextId
+    // ----------------------------------------------------------------------    
+    RPacketContext packetContext2;
+    TBuf<KMaxInfoName + 1> longContextId;
+    _LIT(KLongId, "qwertyuiopasdfghj");
+    longContextId.Copy(KLongId);
+	err = packetContext2.OpenExistingContext(packetService, longContextId);    
+	ASSERT_EQUALS(KErrOverflow, err);
+	
+	// -----------------------------------------------------------------------
+    // Test contextId == KStringExternal, but when iDialUpContext is NOT created
+    // ----------------------------------------------------------------------    
+    RPacketContext packetContext3;
+    TInfoName longContextId3;
+    _LIT( KStringExternal,  "External"  );
+    longContextId3.Copy(KStringExternal);
+	err = packetContext3.OpenExistingContext(packetService, longContextId3);    
+	ASSERT_EQUALS(KErrNotFound, err);		
+
+    //-------------------------------------------------------------------------
+	// Test with epmty contextId
+ 	//-------------------------------------------------------------------------
+ 	RPacketContext packetContext4;
+ 	contextId.Zero();
+    // there should be expected KErrBadName panic  	
+ 	err = packetContext4.OpenExistingContext(packetService, contextId); 	
+ 	
+	AssertMockLtsyStatusL();
+	CleanupStack::PopAndDestroy(1, this); // this
+	}
+