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

	}