diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simtsy/test/Te_Sim/Te_SimPacketTest.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/simtsy/test/Te_Sim/Te_SimPacketTest.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,398 @@
+// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+/**
+ @file
+*/
+
+#include "Te_SimPacketTest.h"
+
+CSimPacketsTest::CSimPacketsTest() 
+	{ 
+	SetTestStepName(_L("PacketTest"));
+	}
+
+TVerdict CSimPacketsTest::doTestStepL()
+	{
+	INFO_PRINTF1(_L("BeginPacketTest"));
+
+ 	CreateConfigFileL(_L("c:\\config3.txt"));
+ 	SetTestNumberL(9);
+
+	INFO_PRINTF1(_L("RPacketService Functionality"));
+
+	// test RPacketService::Open
+	TInt ret = iPhone.Open(iTelServer,KPhoneName); 
+	INFO_PRINTF2(_L("Result: %d"),ret); 
+	TESTL(ret == KErrNone); 
+	INFO_PRINTF1(_L("Opened phone object"));
+	//TESTL(iPacketService.Open(iPhone)==KErrNone);
+	ret = iPacketService.Open(iPhone);
+	INFO_PRINTF1(_L("Opened Packet object"));
+	CHECKPOINTL(ret,KErrNone,CHP_SRVS_CASE("E.1"));
+
+	RPacketService::TRegistrationStatus regStatus;
+	TRequestStatus stat0;
+	TRequestStatus reqStatus;
+
+	// test network RPacketService::GetNtwkRegStatus
+	INFO_PRINTF1(_L(""));
+	INFO_PRINTF1(_L("Testing Get Current Registration Status"));
+	iPacketService.GetNtwkRegStatus(stat0, regStatus);
+	User::WaitForRequest(stat0);
+	TESTL(stat0==KErrNone);
+	TESTL(regStatus==RPacketService::ENotRegisteredSearching);
+	INFO_PRINTF1(_L("GETNTWK:  Searching for network"));
+
+	// test RPacketService::NotifyChangeOfNtwkRegStatus
+	INFO_PRINTF1(_L("Testing Registration Status Change Notification"));
+	iPacketService.NotifyChangeOfNtwkRegStatus(stat0, regStatus);
+	User::WaitForRequest(stat0);
+	TESTL(stat0==KErrNone);
+	TESTL(regStatus==RPacketService::ENotRegisteredSearching);
+	INFO_PRINTF1(_L("NOTIFY NTWK: Registered on home network"));
+
+	// test RPacketService::NotifyChangeOfNtwkRegStatus
+	INFO_PRINTF1(_L("Testing Registration Status Change Notification"));
+	iPacketService.NotifyChangeOfNtwkRegStatus(stat0, regStatus);
+	User::WaitForRequest(stat0);
+	TESTL(stat0==KErrNone);
+	TESTL(regStatus==RPacketService::ERegisteredOnHomeNetwork);
+	INFO_PRINTF1(_L("NOTIFY NTWK: Roaming"));
+
+	// test RPacketService::GetStatus
+	RPacketService::TStatus packetStatus;
+	TRequestStatus notifyStatus;
+	TESTL(iPacketService.GetStatus(packetStatus)==KErrNone);
+	TESTL(packetStatus==RPacketService::EStatusUnattached);
+	INFO_PRINTF1(_L("GET: Packet status is EStatusUnattached"));
+
+	// test RPacketService::NotifyStatusChange
+	iPacketService.NotifyStatusChange(notifyStatus,packetStatus);
+	iPacketService.CancelAsyncRequest(EPacketNotifyStatusChange);
+	User::WaitForRequest(notifyStatus);
+	TESTL(notifyStatus.Int()==KErrCancel);
+	TESTL(packetStatus==RPacketService::EStatusUnattached);
+	INFO_PRINTF1(_L("NOTIFY CANCEL: Packet status is EStatusUnattached"));
+
+    // put defaultConfigGPRS on heap to avoid chkstk problem in CCover build
+	RPacketContext::TContextConfigGPRS* defaultConfigGPRS = new(ELeave) RPacketContext::TContextConfigGPRS;
+    CleanupStack::PushL(defaultConfigGPRS);
+	TPckg<RPacketContext::TContextConfigGPRS> defaultConfigPckgGPRS(*defaultConfigGPRS);
+
+	defaultConfigGPRS->iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+	defaultConfigGPRS->iAnonymousAccessReqd = DPCKTTSY_ANONYMOUS_ACCESS1;
+	defaultConfigGPRS->iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+	defaultConfigGPRS->iPdpCompression = DPCKTTSY_COMPRESSION1;
+	defaultConfigGPRS->iPdpType = DPCKTTSY_PDP_TYPE1;
+	defaultConfigGPRS->iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+	defaultConfigGPRS->iProtocolConfigOption.iAuthInfo.iProtocol = SIM_PACKET_CONTEXT_PROTOCOL1;
+	defaultConfigGPRS->iProtocolConfigOption.iAuthInfo.iUsername = SIM_PACKET_CONTEXT_USERNAME1;
+	defaultConfigGPRS->iProtocolConfigOption.iAuthInfo.iPassword = SIM_PACKET_CONTEXT_PASSWORD1;
+	defaultConfigGPRS->iProtocolConfigOption.iChallenge = SIM_PACKET_CONTEXT_CHALLENGE1;
+	defaultConfigGPRS->iProtocolConfigOption.iResponse = SIM_PACKET_CONTEXT_RESPONSE1;
+	defaultConfigGPRS->iProtocolConfigOption.iDnsAddresses.iPrimaryDns = SIM_PACKET_CONTEXT_PRIMARYSERVER1;
+	defaultConfigGPRS->iProtocolConfigOption.iDnsAddresses.iSecondaryDns = SIM_PACKET_CONTEXT_SECONDARYSERVER1;
+	defaultConfigGPRS->iProtocolConfigOption.iId = SIM_PACKET_CONTEXT_ID1;
+
+	TESTL(iPacketService.SetDefaultContextParams(defaultConfigPckgGPRS) == KErrNone);
+	INFO_PRINTF1(_L("SetDefault Params GPRS test Passed"));
+
+	// test RPacketService::GetDefaultContextParams
+	TESTL(iPacketService.GetDefaultContextParams(defaultConfigPckgGPRS) == KErrNone);
+	TESTL(defaultConfigGPRS->iAccessPointName==DPCKTTSY_ACCESS_POINT1);
+	TESTL(defaultConfigGPRS->iAnonymousAccessReqd==DPCKTTSY_ANONYMOUS_ACCESS1);
+	TESTL(defaultConfigGPRS->iPdpAddress==DPCKTTSY_PDP_ADDRESS1);
+	TESTL(defaultConfigGPRS->iPdpCompression==DPCKTTSY_COMPRESSION1);
+	TESTL(defaultConfigGPRS->iPdpType==DPCKTTSY_PDP_TYPE1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iAuthInfo.iProtocol == SIM_PACKET_CONTEXT_PROTOCOL1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iAuthInfo.iUsername == SIM_PACKET_CONTEXT_USERNAME1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iAuthInfo.iPassword == SIM_PACKET_CONTEXT_PASSWORD1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iChallenge == SIM_PACKET_CONTEXT_CHALLENGE1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iResponse == SIM_PACKET_CONTEXT_RESPONSE1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iDnsAddresses.iPrimaryDns == SIM_PACKET_CONTEXT_PRIMARYSERVER1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iDnsAddresses.iSecondaryDns == SIM_PACKET_CONTEXT_SECONDARYSERVER1);
+	TESTL(defaultConfigGPRS->iProtocolConfigOption.iId == SIM_PACKET_CONTEXT_ID1);
+	INFO_PRINTF1(_L("GetDefault Params GPRS test Passed"));
+
+	// test config UMTS RPacketService::GetDefaultContextParams
+	RPacketContext::TContextConfigR99_R4 defaultConfigR99_R4;
+	TPckg<RPacketContext::TContextConfigR99_R4> defaultConfigPckgR99_R4(defaultConfigR99_R4);
+
+	defaultConfigR99_R4.iAccessPointName = DPCKTTSY_ACCESS_POINT1;
+	defaultConfigR99_R4.iPdpAddress = DPCKTTSY_PDP_ADDRESS1;
+	defaultConfigR99_R4.iPdpType = DPCKTTSY_PDP_TYPE1;
+	defaultConfigR99_R4.iUseEdge = DPCKTTSY_EGPRS_REQUIRED;
+	defaultConfigR99_R4.iProtocolConfigOption.iAuthInfo.iProtocol = SIM_PACKET_CONTEXT_PROTOCOL2;
+	defaultConfigR99_R4.iProtocolConfigOption.iAuthInfo.iUsername = SIM_PACKET_CONTEXT_USERNAME2;
+	defaultConfigR99_R4.iProtocolConfigOption.iAuthInfo.iPassword = SIM_PACKET_CONTEXT_PASSWORD2;
+	defaultConfigR99_R4.iProtocolConfigOption.iChallenge = SIM_PACKET_CONTEXT_CHALLENGE2;
+	defaultConfigR99_R4.iProtocolConfigOption.iResponse = SIM_PACKET_CONTEXT_RESPONSE2;
+	defaultConfigR99_R4.iProtocolConfigOption.iDnsAddresses.iPrimaryDns = SIM_PACKET_CONTEXT_PRIMARYSERVER2;
+	defaultConfigR99_R4.iProtocolConfigOption.iDnsAddresses.iSecondaryDns = SIM_PACKET_CONTEXT_SECONDARYSERVER2;
+	defaultConfigR99_R4.iProtocolConfigOption.iId = SIM_PACKET_CONTEXT_ID2;
+
+	TESTL(iPacketService.SetDefaultContextParams(defaultConfigPckgR99_R4) == KErrNone);
+	INFO_PRINTF1(_L("SetDefault Params R99_R4 test Passed"));
+
+	// test RPacketService::GetDefaultContextParams
+	TESTL(iPacketService.GetDefaultContextParams(defaultConfigPckgR99_R4) == KErrNone);
+	TESTL(defaultConfigR99_R4.iAccessPointName==DPCKTTSY_ACCESS_POINT1);
+	TESTL(defaultConfigR99_R4.iPdpAddress==DPCKTTSY_PDP_ADDRESS1);
+	TESTL(defaultConfigR99_R4.iPdpType==DPCKTTSY_PDP_TYPE1);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iAuthInfo.iProtocol == SIM_PACKET_CONTEXT_PROTOCOL2);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iAuthInfo.iUsername == SIM_PACKET_CONTEXT_USERNAME2);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iAuthInfo.iPassword == SIM_PACKET_CONTEXT_PASSWORD2);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iChallenge == SIM_PACKET_CONTEXT_CHALLENGE2);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iResponse == SIM_PACKET_CONTEXT_RESPONSE2);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iDnsAddresses.iPrimaryDns == SIM_PACKET_CONTEXT_PRIMARYSERVER2);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iDnsAddresses.iSecondaryDns == SIM_PACKET_CONTEXT_SECONDARYSERVER2);
+	TESTL(defaultConfigR99_R4.iProtocolConfigOption.iId == SIM_PACKET_CONTEXT_ID2);
+
+	INFO_PRINTF1(_L("GetDefault Params Rel99 test Passed"));
+
+	//Test R5 RPacketService::SetDefaultContextParams
+	RPacketContext::TContextConfig_R5* defaultConfigR5 = new(ELeave) RPacketContext::TContextConfig_R5;
+	CleanupStack::PushL(defaultConfigR5);
+	TPckg<RPacketContext::TContextConfig_R5> defaultConfigPckgR5(*defaultConfigR5);
+
+	defaultConfigR5->iAccessPointName = R5_CONTEXT_GGSN;
+	defaultConfigR5->iPdpAddress = R5_CONTEXT_PDP_ADDRESS;
+	defaultConfigR5->iPdpType = R5_CONTEXT_PROTOCOL;
+	defaultConfigR5->iUseEdge = R5_CONTEXT_USE_EDGE;
+	defaultConfigR5->iProtocolConfigOption.iAuthInfo.iProtocol = R5_CONTEXT_AUTH_PROT;
+	defaultConfigR5->iProtocolConfigOption.iAuthInfo.iUsername = R5_CONTEXT_USERNAME;
+	defaultConfigR5->iProtocolConfigOption.iAuthInfo.iPassword = R5_CONTEXT_PASSWORD;
+	defaultConfigR5->iProtocolConfigOption.iChallenge = R5_CONTEXT_CHALLENGE;
+	defaultConfigR5->iProtocolConfigOption.iResponse = R5_CONTEXT_RESPONSE;
+	defaultConfigR5->iProtocolConfigOption.iDnsAddresses.iPrimaryDns = R5_CONTEXT_DNS1;
+	defaultConfigR5->iProtocolConfigOption.iDnsAddresses.iSecondaryDns = R5_CONTEXT_DNS2;
+	defaultConfigR5->iProtocolConfigOption.iId = R5_CONTEXT_ID;
+	defaultConfigR5->iPdpHeaderCompression = R5_CONTEXT_HEADER_COMPRESSION;
+	defaultConfigR5->iPdpDataCompression = R5_CONTEXT_DATA_COMPRESSION;
+
+	TBuf8<R5_CONTEXT_ADDITIONAL_PARAM_LEN> additionalParamData(R5_CONTEXT_ADDITIONAL_PARAM);	
+	additionalParamData.SetLength(R5_CONTEXT_ADDITIONAL_PARAM_LEN);
+
+	RPacketContext::TPcoId pcoId(R5_CONTEXT_PCO_ID);
+
+	RPacketContext::TMiscProtocolBuffer miscBuffer;
+	miscBuffer.Zero();
+	
+	TPtr8 pcoPtr(const_cast<TUint8*>(miscBuffer.Ptr()), 
+		RPacketContext::KMiscProtocolBufferLength);	
+
+	TPtr8 additionalParamDataPtr(const_cast<TUint8*>(additionalParamData.Ptr()),
+		additionalParamData.Length(), additionalParamData.Length());
+
+	// Attach TTlv  to the buffer
+	TTlvStruct<RPacketContext::TPcoId,RPacketContext::TPcoItemDataLength> theTLV(pcoPtr,0);	
+
+	theTLV.AppendItemL(pcoId,additionalParamDataPtr);
+
+	miscBuffer.SetLength(pcoPtr.Length());
+
+	defaultConfigR5->iProtocolConfigOption.iMiscBuffer = miscBuffer;
+	ret = iPacketService.SetDefaultContextParams(defaultConfigPckgR5);	
+
+	CHECKPOINTL(ret,KErrNone,CHP_IMS_CASE("P.1"));
+	INFO_PRINTF1(_L("SetDefault Params R5 test Passed"));
+	
+	CleanupStack::PopAndDestroy(defaultConfigR5);
+
+	//Test R5 RPacketService::GetDefaultContextParams
+	RPacketContext::TContextConfig_R5* defaultConfigR5_2 = new(ELeave) RPacketContext::TContextConfig_R5;
+	CleanupStack::PushL(defaultConfigR5_2);
+	TPckg<RPacketContext::TContextConfig_R5> defaultConfigPckgR5_2(*defaultConfigR5_2);
+
+	ret = iPacketService.GetDefaultContextParams(defaultConfigPckgR5_2);
+	CHECKPOINTL(ret,KErrNone,CHP_IMS_CASE("P.2"));
+
+	TESTL(defaultConfigR5_2->iAccessPointName == R5_CONTEXT_GGSN);
+	TESTL(defaultConfigR5_2->iPdpAddress == R5_CONTEXT_PDP_ADDRESS);
+	TESTL(defaultConfigR5_2->iPdpType == R5_CONTEXT_PROTOCOL);
+	TESTL(defaultConfigR5_2->iUseEdge == R5_CONTEXT_USE_EDGE);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iAuthInfo.iProtocol == R5_CONTEXT_AUTH_PROT);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iAuthInfo.iUsername == R5_CONTEXT_USERNAME);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iAuthInfo.iPassword == R5_CONTEXT_PASSWORD);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iChallenge == R5_CONTEXT_CHALLENGE);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iResponse == R5_CONTEXT_RESPONSE);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iDnsAddresses.iPrimaryDns == R5_CONTEXT_DNS1);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iDnsAddresses.iSecondaryDns == R5_CONTEXT_DNS2);
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iId == R5_CONTEXT_ID);
+	TESTL(defaultConfigR5_2->iPdpHeaderCompression == R5_CONTEXT_HEADER_COMPRESSION);
+	TESTL(defaultConfigR5_2->iPdpDataCompression == R5_CONTEXT_DATA_COMPRESSION);
+	defaultConfigR5_2->iProtocolConfigOption.iMiscBuffer.SetLength(miscBuffer.Length());
+	TESTL(defaultConfigR5_2->iProtocolConfigOption.iMiscBuffer == miscBuffer);
+	INFO_PRINTF1(_L("GetDefault Params Rel5 test Passed"));
+
+	CleanupStack::PopAndDestroy(defaultConfigR5_2);
+
+	// test RPacketService::Attach
+	iPacketService.Attach(reqStatus);
+	iPacketService.CancelAsyncRequest(EPacketAttach);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus==KErrCancel);
+	INFO_PRINTF1(_L("Packet Attach Cancelled Successfully"));
+	CHECKPOINTL(ret,KErrNone,CHP_CNTXT_CASE("E.9"));
+
+	// test RPacketService::GetStatus
+	TESTL(iPacketService.GetStatus(packetStatus)==KErrNone);
+	TESTL(packetStatus==RPacketService::EStatusUnattached);
+	INFO_PRINTF1(_L("GET: Packet status is EStatusUnattached"));
+
+	// test RPacketService::NotifyStatusChange
+	iPacketService.NotifyStatusChange(notifyStatus,packetStatus);
+
+	// test RPacketService::Attach
+	iPacketService.Attach(reqStatus);
+	User::WaitForRequest(notifyStatus);
+	User::WaitForRequest(reqStatus);
+	TESTL(notifyStatus.Int()==KErrNone);
+	TESTL(reqStatus==KErrNone);
+	TESTL(packetStatus==RPacketService::EStatusAttached);
+	INFO_PRINTF1(_L("NOTIFY: Packet status is EStatusAttached"));
+	INFO_PRINTF1(_L("Packet Attached to network"));
+	CHECKPOINTL(ret,KErrNone,CHP_CNTXT_CASE("E.8"));
+
+	// test RPacketService::Detach
+	iPacketService.Detach(reqStatus);
+	iPacketService.CancelAsyncRequest(EPacketDetach);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus==KErrCancel);
+	CHECKPOINTL(ret,KErrNone,CHP_CNTXT_CASE("E.10"));
+	INFO_PRINTF1(_L("Packet Detach Cancelled Successfully"));
+
+	// test RPacketService::GetStatus
+	TESTL(iPacketService.GetStatus(packetStatus)==KErrNone);
+	TESTL(packetStatus==RPacketService::EStatusAttached);
+	INFO_PRINTF1(_L("GET: Packet status is EStatusAttached 2"));
+
+	// test RPacketService::NotifyStatusChange
+	iPacketService.NotifyStatusChange(notifyStatus,packetStatus);
+
+	// test RPacketService::Detach
+	iPacketService.Detach(reqStatus);
+	User::WaitForRequest(notifyStatus);
+	TESTL(notifyStatus.Int()==KErrNone);
+	TESTL(packetStatus==RPacketService::EStatusUnattached);
+	INFO_PRINTF1(_L("NOTIFY: Packet status is EStatusUnattached"));
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus==KErrNone);
+	CHECKPOINTL(ret,KErrNone,CHP_CNTXT_CASE("E.11"));
+	INFO_PRINTF1(_L("Packet Detached from network"));
+
+	// test RPacketService::EnumerateContexts
+	TInt contextCount, maxAllowed;
+	iPacketService.EnumerateContexts(reqStatus,contextCount, maxAllowed);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNone);
+	TESTL(contextCount==0);
+	TESTL(maxAllowed==11);
+	CHECKPOINTL(ret,KErrNone,CHP_CNTXT_CASE("E.4"));
+	INFO_PRINTF2(_L("Enumerate Context: %d"), contextCount);
+
+	// test RPacketService::GetContextInfo
+	TInt index = 0;
+	RPacketService::TContextInfo contextInfo;
+	iPacketService.GetContextInfo(reqStatus, index, contextInfo);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrArgument); // So far no context created
+	CHECKPOINTL(reqStatus.Int(),KErrArgument,CHP_CNTXT_CASE("E.5"));
+
+	// test RPacketService::GetMSClass
+	RPacketService::TMSClass msClass1, msClass2;
+	iPacketService.GetMSClass(reqStatus, msClass1,msClass2);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNone);
+	TESTL(msClass1==RPacketService::EMSClassSuspensionRequired);
+	TESTL(msClass2==RPacketService::EMSClassSuspensionRequired);
+	INFO_PRINTF1(_L("GetMSClass successful"));
+
+	iPacketService.GetMSClass(reqStatus, msClass1, msClass2);
+	iPacketService.CancelAsyncRequest(EPacketGetMSClass);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNone); //can't be cancelled in the simtsy so it GetMSClass should complete.
+	INFO_PRINTF1(_L("GetMSClass Cancel does not cancel"));
+
+	// test RPacketService::SetMSClass
+	msClass1 = RPacketService::EMSClassSuspensionRequired;
+
+	iPacketService.SetMSClass(reqStatus, RPacketService::EMSClassSuspensionRequired);
+	iPacketService.CancelAsyncRequest(EPacketSetMSClass);//no implementation-does nothing
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNone);
+	iPacketService.SetMSClass(reqStatus, RPacketService::EMSClassDualMode);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNotSupported);
+	INFO_PRINTF1(_L("SetMSClass successful"));
+
+	iPacketService.SetMSClass(reqStatus, msClass1);
+	iPacketService.CancelAsyncRequest(EPacketSetMSClass);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNone);
+	INFO_PRINTF1(_L("SetMSClass Cancel does not cancel"));
+
+	// test RPacketService::NotifyMSClassChange
+	iPacketService.NotifyMSClassChange(reqStatus, msClass1);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNotSupported);
+	INFO_PRINTF1(_L("NotifyMSClass not supported successful"));
+
+	iPacketService.NotifyMSClassChange(reqStatus, msClass1);
+	iPacketService.CancelAsyncRequest(EPacketNotifyMSClassChange);
+	User::WaitForRequest(reqStatus);
+	TESTL(reqStatus.Int()==KErrNotSupported);
+	INFO_PRINTF1(_L("NotifyMSClass cancel not supported successful"));
+
+	// test RPacketService::GetStaticCaps
+	TUint caps;
+	TESTL(iPacketService.GetStaticCaps(caps, DPCKTTSY_PDP_TYPE1)==KErrNone);
+	TESTL(caps==SIM_PACKET_SERVICE_CAPS);
+	INFO_PRINTF1(_L("Get Static Caps test passed"));
+
+	// RPacketService::GetDynamicCaps is tested by te_simpacket
+
+	// test RPacketService::SetAttachMode
+	RPacketService::TAttachMode attachMode=RPacketService::EAttachWhenNeeded;
+	TESTL(iPacketService.SetAttachMode(attachMode)==KErrNone);
+
+	// test RPacketService::GetAttachMode
+	TESTL(iPacketService.GetAttachMode(attachMode)==KErrNone);
+	TESTL(attachMode==RPacketService::EAttachWhenNeeded);
+	
+	// test RPacketService::NotifyAttachModeChange
+	RPacketService::TAttachMode notifyAttachMode;
+	iPacketService.NotifyAttachModeChange(reqStatus, notifyAttachMode);
+	TESTL(iPacketService.SetAttachMode(attachMode)==KErrNone);
+	User::WaitForRequest(reqStatus);	
+	TESTL(reqStatus==KErrNone);
+	TESTL(notifyAttachMode==RPacketService::EAttachWhenNeeded);	
+	
+	// test RPacketService::NotifyAttachModeChange & Cancel
+	iPacketService.NotifyAttachModeChange(reqStatus, notifyAttachMode);
+	iPacketService.CancelAsyncRequest(EPacketNotifyAttachModeChange);
+	User::WaitForRequest(reqStatus);	
+	TESTL(reqStatus==KErrCancel);
+
+    CleanupStack::PopAndDestroy(1);
+
+	iPacketService.Close();
+	iPhone.Close();
+	ASSERT(RThread().RequestCount()==0);
+
+	return TestStepResult();
+	}
+