1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 /**

    19  @file The TEFUnit test suite for PacketServicesControl in the Common TSY.

    20 */

    21 

    22 #include "cctsypacketservicesfu.h"

    23 #include <etel.h>

    24 #include <etelmm.h>

    25 #include <in_sock.h>

    26 #include <et_clsvr.h>

    27 #include <ctsy/mmtsy_names.h>

    28 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    29 #include <test/tmockltsydata.h>

    30 #include <ctsy/serviceapi/gsmerror.h>

    31 #include <ctsy/ltsy/mltsydispatchpacketservicesinterface.h>

    32 #include <pcktcs.h>

    33 #include "mockltsyindicatorids.h"

    34 #include <mbmstypes.h>

    35 #include "listretrieverao.h"

    36 

    37 CTestSuite* CCTsyPacketServicesFU::CreateSuiteL(const TDesC& aName)

    38 	{

    39 	SUB_SUITE;

    40 	

    41 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUseCase0001L);

    42   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUseCase0002L);

    43   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUseCase0003L);

    44   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUseCase0004L);

    45   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUseCase0005L);

    46   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUseCase0006L);

    47   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUseCase0007L);

    48    

    49    	//add other unit tests

    50   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0001L);

    51  	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0002L);

    52   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0003L);

    53   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0004L);

    54   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0005L);

    55   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0006L);

    56   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0007L);

    57   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0008L);

    58   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit0009L);

    59   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00010L);

    60   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00011AL);

    61   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00011BL);

    62   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00011CL);

    63   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00012L);

    64   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00013L);

    65   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00014L);

    66   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00015L);

    67   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00016L);

    68   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00017L);

    69   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00018L);

    70  	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00019L);

    71   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00020L);

    72  	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00021L);

    73   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00022L);

    74   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00023L);

    75   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00024L);

    76   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00025L);

    77   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFU, TestUnit00026L);

    78 

    79 	END_SUITE;

    80 	}

    81 

    82 

    83 //

    84 // Drivers

    85 //

    86 

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

    88 void CCTsyPacketServicesFU::ConvertDNSToPCOBuffer

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

    90 	{

    91 	// Handle Primary DNS address

    92 	TInetAddr netPrimaryDNS;

    93 	TBuf<KDnsLength> netPrimaryDNSConv;

    94 	netPrimaryDNSConv.Copy(aPrimaryDNS);

    95 	netPrimaryDNS.Input(netPrimaryDNSConv);

    96 	TUint32 primDNSaddr =  netPrimaryDNS.Address();

    97 

    98 	// Handle Secondary DNS address

    99 	TInetAddr netSecondaryDNS;

   100 	TBuf<KDnsLength> netSecondaryDNSConv;

   101 	netSecondaryDNSConv.Copy(aSecondaryDNS);

   102 	netSecondaryDNS.Input(netSecondaryDNSConv);

   103 	TUint32 secondaryDNSaddr =  netSecondaryDNS.Address();

   104 

   105 	aFormatPcoBufferAddr[0] = KPrimaryAndSecondaryDNSLength;	// Length

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   122 	aFormatPcoBufferAddr.SetLength(KPrimaryAndSecondaryDNSLength + 1);

   123 	}

   124 

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

   126 void CCTsyPacketServicesFU::ConvertUsernameAndPasswordToPCOBuffer(const TDes8& aUsername, 

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

   128 	{

   129 	TInt usernameLen = aUsername.Length();

   130 	TInt passwordLen = aPassword.Length();

   131 	TInt dataLen = usernameLen + passwordLen + KPasswordUsernameHeaderLength;

   132 	TInt i = 0;

   133 

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

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

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

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

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

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

   140 	aFormatedBuffer.SetLength(i);

   141 	aFormatedBuffer.Append(aUsername); 				// Username

   142 	aFormatedBuffer.SetLength(i + usernameLen + 1);

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

   144 	aFormatedBuffer.Append(aPassword);				// Password

   145 	}

   146 

   147 /***

   148 * 											PCO - Description

   149 *

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

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

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

   153 * or an application.

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

   155 * octets and a maximum length of 253 octets

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

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

   158 *  

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

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

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

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

   163 * (The dispatcher handles the overflow scenario). 

   164 *

   165 * Following is an example of a PCO buffer outline:

   166 *	

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   202 *   

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

   204 *   example above).      

   205 */

   206  

   207 // 

   208 //

   209 //

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

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

   212 	{

   213 

   214 	TBuf8<KMaxUserAndPassLength> userAndPasswordBuffer(KMaxUserAndPassLength);

   215 

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

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

   218 

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

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

   221 

   222 	TBuf8<KMaxPdpAddressLength> primaryAndSecondaryDNSBuffer(KPrimaryAndSecondaryDNSLength + 1);

   223 

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

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

   226 

   227 	// Setting the configurations buffers

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

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

   230 

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

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

   233 

   234 	RPacketContext::TPcoId usenameAndPasswordID(KUsenamePasswordDNSID);

   235 	RPacketContext::TPcoId primaryAndSecondaryDNSID(KPrimaryAndSecondaryDNSID);

   236 

   237 	pcoTlv.AppendItemL(usenameAndPasswordID, userAndPasswordParamDataPtr);

   238 	pcoTlv.AppendItemL(primaryAndSecondaryDNSID, primaryAndSecondaryDNSParamDataPtr);

   239 

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

   241 

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

   243 	aPcoBuffer.Append(aPco.iMiscBuffer);

   244 	}

   245 

   246 void CCTsyPacketServicesFU::DriverDeleteContextL(TInfoName aContextName)

   247 	{

   248 	RBuf8 data;

   249 	CleanupClosePushL(data);

   250 	TMockLtsyData1<TInfoName> contextNameData(aContextName);

   251 	data.Close();

   252 	contextNameData.SerialiseL(data);

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

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

   255 	}

   256 

   257 void CCTsyPacketServicesFU::DriverAttachPacketServiceL()

   258 	{

   259 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId);

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

   261 	}

   262 

   263 void CCTsyPacketServicesFU::DriverDetachPacketServiceL()

   264 	{

   265 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId);

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

   267 

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

   269 	RBuf8 dataExpect;

   270     CleanupClosePushL(dataExpect);

   271     RPacketService::TAttachMode attachMode = RPacketService::EAttachWhenPossible;

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

   273     dataExpect.Close();

   274     ltsyData.SerialiseL(dataExpect);

   275 

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

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

   278 

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

   280 	}

   281 

   282 void CCTsyPacketServicesFU::DriverInitialiseContextL()

   283 	{

   284 	RBuf8 data;

   285 	CleanupClosePushL(data);

   286 

   287 	TInfoName primaryContext;

   288 	TInfoName secondaryContext;

   289 	primaryContext.Copy(KFirstAllocatedContextName);

   290 	secondaryContext.Copy(KDefaultContextName);

   291 

   292 	//-------------------------------------------------------------------------

   293 	// Successful completion request of

   294 	// RPacketContext::InitialiseContext

   295  	//-------------------------------------------------------------------------

   296 

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

   298 	data.Close();

   299 	expLtsyContextNamesData3.SerialiseL(data);

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

   301 

   302 	TDesC* contextNamePtr = &primaryContext;

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

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

   305 	data.Close();

   306 	expLtsyContextNameAndChannelIdData.SerialiseL(data);

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

   308 

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

   310 	}

   311 

   312 void CCTsyPacketServicesFU::DriverInitialiseContextL(const TInfoName& aPrimaryContextId, const TInfoName& aSecondaryContextId)

   313 	{

   314 	RBuf8 data;

   315 	CleanupClosePushL(data);

   316 

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

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

   319 

   320 	//-------------------------------------------------------------------------

   321 	// Successful completion request of

   322 	// RPacketContext::InitialiseContext

   323  	//-------------------------------------------------------------------------

   324 

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

   326 	data.Close();

   327 	expLtsyContextNamesData.SerialiseL(data);

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

   329 

   330 

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

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

   333 	

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

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

   336 	data.Close();

   337 	expLtsyContextNameAndPortData2.SerialiseL(data);	

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

   339 

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

   341 	}

   342 

   343 

   344 void CCTsyPacketServicesFU::DriverSetConfigContextL(TInfoName aContextId,

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

   346 		RPacketContext::TProtocolAddress aPdpAddress,

   347 		RPacketContext::TMiscProtocolBuffer aPcoBuffer)

   348 	{

   349 

   350 	RBuf8 data;

   351 	CleanupClosePushL(data);

   352 

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

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

   355 	data.Close();

   356 	packetSetConfigData.SerialiseL(data);

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

   358 

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

   360 	TInfoName callbackContextId = aContextId;

   361 	TMockLtsyData1<TInfoName> callbackContextIdData(callbackContextId);

   362 	data.Close();

   363 	callbackContextIdData.SerialiseL(data);

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

   365 

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

   367 	}

   368 void CCTsyPacketServicesFU::DriverModifyActiveContextL(TInt8 aRejectionCode, TInt aError)

   369 	{

   370 	RBuf8 data;

   371 	CleanupClosePushL(data);

   372 

   373 	TInfoName modifyActiveContextName;

   374 	modifyActiveContextName.Copy(KFirstAllocatedContextName);

   375 	TMockLtsyData1<TInfoName>

   376 		modifyActiveContextNameData(modifyActiveContextName);

   377 	data.Close();

   378 	modifyActiveContextNameData.SerialiseL(data);

   379 

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

   381 

   382 	TMockLtsyData2<TInfoName, TInt8 >

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

   384 	data.Close();

   385 	completeModifyActiveContextData.SerialiseL(data);

   386 

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

   388 

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

   390 	}

   391 

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

   393 	{

   394 	aPacketContext.OpenNewContext(aPacketService, aContextName);

   395 	CleanupClosePushL(aPacketContext);

   396 

   397 	RBuf8 data;

   398 	CleanupClosePushL(data);

   399 	

   400 	TDesC* contextNamePtr = &aContextName;

   401 	TMockLtsyData1<TDesC*> initMbmdContextExpData(contextNamePtr);

   402 	initMbmdContextExpData.SerialiseL(data);

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

   404 	data.Close();

   405 	

   406 	

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

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

   409 	initMbmdContextCompData.SerialiseL(data);

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

   411 	data.Close();

   412 	

   413 	//initialisation of the context

   414 	RPacketContext::TDataChannelV2 dataChannel;

   415 	RPacketContext::TDataChannelV2Pckg dataChannelPckg(dataChannel);

   416 

   417 	TRequestStatus reqStatus;

   418     aPacketContext.InitialiseContext(reqStatus, dataChannelPckg);

   419 	User::WaitForRequest(reqStatus);

   420 	ASSERT_EQUALS(reqStatus.Int(), aCompError);

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

   422 	

   423 	AssertMockLtsyStatusL();

   424 	

   425 	CleanupStack::PopAndDestroy(&data);

   426 	}

   427 

   428 //

   429 // Use Cases

   430 //

   431 

   432 

   433 /**

   434 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-UC0001

   435 @SYMComponent telephony_ctsy

   436 @SYMTestCaseDesc Test support in CTSY for RPacketService::Attach & RPacketService::Detach

   437 @SYMTestPriority High

   438 @SYMTestActions Invokes RPacketService::Attach(), RPacketService::Detach()

   439 @SYMTestExpectedResults Pass

   440 @SYMTestType CT

   441  */

   442 void CCTsyPacketServicesFU::TestUseCase0001L()

   443 	{

   444 	OpenEtelServerL(EUseExtendedError);

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

   446 	OpenPhoneL();

   447 	RBuf8 data;

   448 	CleanupClosePushL(data);

   449 

   450 	// client side test

   451 	RPacketService packetService;

   452 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

   453 

   454 	//

   455 

   456 	DriverAttachPacketServiceL();

   457 	DriverDetachPacketServiceL();

   458 

   459 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesGetPacketAttachMode::KLtsyDispatchPacketServicesGetPacketAttachModeApiId);

   460 	RPacketService::TAttachMode returnedAttachMode = RPacketService::EAttachWhenPossible;

   461 	TMockLtsyData1<RPacketService::TAttachMode > completeGetAttachModetData(returnedAttachMode);

   462 	data.Close();

   463 	completeGetAttachModetData.SerialiseL(data);

   464 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesGetPacketAttachMode::KLtsyDispatchPacketServicesGetPacketAttachModeApiId, KErrNone, data);

   465 

   466 	//

   467 

   468 	TRequestStatus requestAttachStatus;

   469 	RPacketService::TStatus packetStatus;

   470 	packetService.NotifyStatusChange(requestAttachStatus, packetStatus);

   471 

   472 	TRequestStatus attachStatus;

   473 	packetService.Attach(attachStatus);

   474 

   475 	// Wait for Attach to complete

   476 	User::WaitForRequest(attachStatus);

   477 	ASSERT_EQUALS(KErrNone, attachStatus.Int());

   478 	// Wait for notification to complete

   479 	User::WaitForRequest(requestAttachStatus);

   480 	ASSERT_EQUALS(RPacketService::EStatusAttached, packetStatus);

   481 

   482 	RPacketService::TStatus getStatus;

   483 	ASSERT_EQUALS(KErrNone, packetService.GetStatus(getStatus));

   484 	ASSERT_EQUALS(RPacketService::EStatusAttached, getStatus);

   485 

   486 	TRequestStatus requestDetachStatus;

   487 	packetService.NotifyStatusChange(requestDetachStatus, packetStatus);

   488 	// Detach and wait for request

   489 	TRequestStatus detachStatus;

   490 	packetService.Detach(detachStatus);

   491 

   492 	// Wait for Detach to complete

   493 	User::WaitForRequest(detachStatus);

   494 

   495 	// Wait for notification to complete

   496 	User::WaitForRequest(requestDetachStatus);

   497 	ASSERT_EQUALS(KErrNone, detachStatus.Int());

   498 	ASSERT_EQUALS(RPacketService::EStatusUnattached, packetStatus);

   499 	ASSERT_EQUALS(KErrNone, packetService.GetStatus(getStatus));

   500 	ASSERT_EQUALS(RPacketService::EStatusUnattached, getStatus);

   501 

   502 	packetService.NotifyStatusChange(requestAttachStatus, packetStatus);

   503 	

   504 	TRequestStatus attachModeStatus;

   505 	RPacketService::TAttachMode completedAttachMode;

   506 	packetService.GetAttachMode(attachModeStatus, completedAttachMode);

   507 	User::WaitForRequest(attachModeStatus);

   508 	ASSERT_EQUALS(KErrNone, attachModeStatus.Int());

   509 	ASSERT_EQUALS(RPacketService::EAttachWhenPossible, completedAttachMode);

   510 

   511 	packetService.Close();

   512 

   513 	// Let the mock-LTSY finish up before asserting.

   514 	User::After(1000000);

   515 	

   516 	AssertMockLtsyStatusL();

   517 	CleanupStack::PopAndDestroy(3, this); // data, packetService, this

   518 	}

   519 

   520 

   521 /**

   522 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-UC0002

   523 @SYMComponent telephony_ctsy

   524 @SYMTestCaseDesc Test support in CTSY for activation and QoS configuration for R97.

   525 @SYMTestPriority High

   526 @SYMTestActions Invokes RPacketContext::OpenNewContext(), RPacketContext::InitialiseContext(), RPacketContext::SetConfig(), RPacketQoS::OpenNewQoS(), RPacketQoS::SetProfileParameters(), RPacketQoS::NotifyProfileChanged(), RPacketContext::Activate(), RPacketContext::NotifyStatusChange() for R97

   527 @SYMTestExpectedResults Pass

   528 @SYMTestType CT

   529  */

   530 void CCTsyPacketServicesFU::TestUseCase0002L()

   531 	{

   532 	OpenEtelServerL(EUseExtendedError);

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

   534 	OpenPhoneL();

   535 

   536 	RPacketService packetService;

   537 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

   538 

   539 	TInfoName contextId;

   540 	contextId.Copy(KFirstAllocatedContextName);

   541 

   542 	// Prepare context configuration for GPRS

   543 	RPacketContext::TContextConfigGPRS setConfigGPRS;

   544 	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);

   545 	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;

   546 	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);

   547 	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);

   548 	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);

   549 	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;

   550 	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);

   551 	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);

   552 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

   553 	setConfigGPRS.iProtocolConfigOption.iMiscBuffer.Copy(KDummyMiscBuffer);

   554 	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);

   555 

   556 	// Create the PCO buffer

   557 	RPacketContext::TMiscProtocolBuffer pcoBuffer;

   558 	pcoBuffer.Zero();

   559 

   560 	// Generate a PCO buffer

   561 	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, pcoBuffer);

   562 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

   563 	

   564 	//

   565 	// GPRS Configuration

   566 	DriverInitialiseContextL();

   567 	

   568 	DriverSetConfigContextL(contextId, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType, setConfigGPRS.iPdpAddress, pcoBuffer);

   569 	

   570 	RPacketQoS::TQoSGPRSRequested qosExpectedRequestedGPRSProfile;

   571 	qosExpectedRequestedGPRSProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   572 	qosExpectedRequestedGPRSProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   573 	qosExpectedRequestedGPRSProfile.iReqDelay = RPacketQoS::EDelayClass1;

   574 	qosExpectedRequestedGPRSProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;

   575 	qosExpectedRequestedGPRSProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;

   576 	qosExpectedRequestedGPRSProfile.iMinReliability = RPacketQoS::EReliabilityClass1;

   577 	qosExpectedRequestedGPRSProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   578 	qosExpectedRequestedGPRSProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   579 	qosExpectedRequestedGPRSProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

   580 	qosExpectedRequestedGPRSProfile.iMinMeanThroughput = RPacketQoS::EMeanThroughput500;

   581 

   582 	RBuf8 data;

   583 	CleanupClosePushL(data);

   584 	

   585 	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSData(contextId,qosExpectedRequestedGPRSProfile);

   586 	data.Close();

   587 	packetSetConfigGPRSData.SerialiseL(data);

   588 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);

   589 

   590 	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextId);

   591 	callbackSetPdpGPRSContextNameData.SerialiseL(data);

   592 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);

   593 

   594 	// Activate

   595 	TMockLtsyData1<TInfoName> expectedActivateContextNameData(contextId);

   596 	data.Close();

   597 	expectedActivateContextNameData.SerialiseL(data);

   598 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, data, KErrNone);

   599 

   600 	TMockLtsyData3<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolType>

   601 		completedActivateContextNameData(contextId, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType);

   602 	data.Close();

   603 	completedActivateContextNameData.SerialiseL(data);

   604 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, KErrNone, data);

   605 

   606 	RPacketQoS::TQoSGPRSNegotiated completedProfile;

   607 	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSNegotiated> expLtsyQosProfileChangedInd(contextId, completedProfile);

   608 	data.Close();

   609 	expLtsyQosProfileChangedInd.SerialiseL(data);

   610 	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyQosProfileChangedIndId, KErrNone, data);

   611 

   612 	// Prepare context configuration for GPRS

   613 	RPacketContext::TContextConfigGPRS setConfigGPRSActive;

   614 	setConfigGPRSActive.iAccessPointName.Copy(KPointNameGPRS);

   615 	setConfigGPRSActive.iPdpType = RPacketContext::EPdpTypeIPv4;

   616 	setConfigGPRSActive.iPdpCompression = 0;

   617 	setConfigGPRSActive.iPdpAddress.Copy(KPdpAddGPRSActive);

   618 	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);

   619 	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);

   620 	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;

   621 	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);

   622 	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);

   623 

   624 	TMockLtsyData5<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolAddress, TUint, RPacketContext::TMiscProtocolBuffer>

   625 					expLtsyProfileChangedInd(contextId, setConfigGPRSActive.iAccessPointName,

   626 					setConfigGPRSActive.iPdpAddress, setConfigGPRSActive.iPdpCompression, pcoBuffer);

   627 	data.Close();

   628 	expLtsyProfileChangedInd.SerialiseL(data);

   629 	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyPdpContextConfigChangedIndId, KErrNone, data);

   630 

   631 	TMockLtsyData1<TInfoName> deactivateContextNameData(contextId);

   632 	data.Close();

   633 	deactivateContextNameData.SerialiseL(data);

   634 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, data, KErrNone);

   635 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, KErrNone, data);

   636 	

   637 	DriverDeleteContextL(contextId);

   638 

   639 	//

   640 

   641 	// client side test

   642 	RPacketContext packetContext;

   643 

   644 	// Open a new context

   645 	TInt err = packetContext.OpenNewContext(packetService, contextId);

   646 	CleanupClosePushL(packetContext);

   647 	ASSERT_EQUALS(KErrNone, err);

   648 

   649 	RPacketContext::TDataChannelV2 dataChannel;

   650 	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);

   651 	TRequestStatus initialiseContextStatus;

   652 

   653 	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);

   654 	User::WaitForRequest(initialiseContextStatus);

   655 

   656 	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());

   657 	ASSERT_TRUE(dataChannel.iPort == KFirstAllocatedContextName);

   658 	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId); // now deprecated

   659 

   660 	TRequestStatus setConfigStatus;

   661 	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);

   662 	

   663 	User::WaitForRequest(setConfigStatus);

   664 	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());

   665 

   666 	TName qosName;

   667 	RPacketQoS packetQoS;

   668 	packetQoS.OpenNewQoS(packetContext, qosName);

   669 	CleanupClosePushL(packetQoS);

   670 

   671 	//

   672     // SetProfileParameters for GPRS Configurations

   673     //

   674 

   675 	RPacketQoS::TQoSGPRSRequested qosGPRSRequestedProfile;

   676 	qosGPRSRequestedProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   677 	qosGPRSRequestedProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   678 	qosGPRSRequestedProfile.iReqDelay = RPacketQoS::EDelayClass1;

   679 	qosGPRSRequestedProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;

   680 	qosGPRSRequestedProfile.iReqReliability =  RPacketQoS::EUnspecifiedReliabilityClass;

   681 	qosGPRSRequestedProfile.iMinReliability = RPacketQoS::EReliabilityClass1;

   682 	qosGPRSRequestedProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   683 	qosGPRSRequestedProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   684 	qosGPRSRequestedProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

   685 	qosGPRSRequestedProfile.iMinMeanThroughput = RPacketQoS::EMeanThroughput500;

   686 	TPckg< RPacketQoS::TQoSGPRSRequested > profilePckgGPRS(qosGPRSRequestedProfile);

   687 	

   688 	TRequestStatus notifyProfileChangeStatus;

   689 	RPacketQoS::TQoSGPRSNegotiated profile;

   690 	TPckg<RPacketQoS::TQoSGPRSNegotiated> qosGPRSNegotiatedProfilePk(profile);

   691 	packetQoS.NotifyProfileChanged(notifyProfileChangeStatus, qosGPRSNegotiatedProfilePk);

   692 	

   693 	TRequestStatus requestStatusGPRS;

   694 	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);

   695 	User::WaitForRequest(requestStatusGPRS);

   696 	ASSERT_EQUALS(KErrNone, requestStatusGPRS.Int());

   697 	//

   698 

   699 	RPacketContext::TContextConfigGPRS setConfigGPRSActiveNotifyConfigChanged;

   700 	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRSNotifyConfigChanged(setConfigGPRSActiveNotifyConfigChanged);

   701 

   702 	TRequestStatus contextConfigStatus;

   703 	packetContext.NotifyConfigChanged(contextConfigStatus, pckgConfigGPRSNotifyConfigChanged);

   704 

   705 	TRequestStatus contextActivatingRequestStatus;

   706 	RPacketContext::TContextStatus contextStatus;

   707 	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);

   708 

   709 	TRequestStatus activateStatus;

   710 	packetContext.Activate(activateStatus);

   711 	User::WaitForRequest(activateStatus);

   712 	User::WaitForRequest(contextActivatingRequestStatus);

   713 	ASSERT_EQUALS(KErrNone, activateStatus.Int());

   714 	ASSERT_EQUALS(RPacketContext::EStatusActivating, contextStatus);

   715 

   716 	// Complete NotifyProfileChanged

   717 	User::WaitForRequest(notifyProfileChangeStatus);

   718 	ASSERT_EQUALS(KErrNone, notifyProfileChangeStatus.Int());

   719 

   720 	// Status change from RPacketContext::EStatusActivating to RPacketContext::EStatusActive

   721 	TRequestStatus contextActivateRequestStatus;

   722 	RPacketContext::TContextStatus contextActiveStatus;

   723 	packetContext.NotifyStatusChange(contextActivateRequestStatus, contextActiveStatus);

   724 

   725 	// Complete NotifyConfigChanged	

   726 	User::WaitForRequest(contextActivateRequestStatus);	

   727 	ASSERT_EQUALS(KErrNone, contextActivateRequestStatus.Int());

   728 	ASSERT_EQUALS(RPacketContext::EStatusActive, contextActiveStatus);

   729 	

   730 	TRequestStatus deactivateContextStatus;

   731 	packetContext.Deactivate(deactivateContextStatus);

   732 	User::WaitForRequest(deactivateContextStatus);

   733 	ASSERT_EQUALS(KErrNone, deactivateContextStatus.Int())

   734 

   735 	packetQoS.Close();

   736 	packetContext.Close();

   737 	packetService.Close();

   738 

   739 	// Let the mock-LTSY finish up before asserting.

   740 	User::After(1000000);

   741 	

   742 	AssertMockLtsyStatusL();

   743 	CleanupStack::PopAndDestroy(5, this); // data, packetQoS, packetService, packetContext, this

   744 	}

   745 

   746 

   747 /**

   748 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-UC0003

   749 @SYMComponent telephony_ctsy

   750 @SYMTestCaseDesc Test support in CTSY for activation and QoS configuration for R99.

   751 @SYMTestPriority High

   752 @SYMTestActions Invokes RPacketContext::OpenNewContext(), RPacketContext::InitialiseContext(), RPacketContext::SetConfig(), RPacketQoS::OpenNewQoS(), RPacketQoS::SetProfileParameters(), RPacketQoS::NotifyProfileChanged(), RPacketContext::Activate(), RPacketContext::NotifyStatusChange() for R99

   753 @SYMTestExpectedResults Pass

   754 @SYMTestType CT

   755  */

   756 void CCTsyPacketServicesFU::TestUseCase0003L()

   757 	{

   758 	OpenEtelServerL(EUseExtendedError);

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

   760 	OpenPhoneL();

   761 

   762 	RPacketService packetService;

   763 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

   764 

   765 	TInfoName contextId;

   766 	contextId.Copy(KFirstAllocatedContextName);

   767 

   768 	// Prepare context configuration for R4R99

   769 	RPacketContext::TContextConfigR99_R4 setConfig99;

   770 	setConfig99.iAccessPointName.Copy(KPointName99);

   771 	setConfig99.iPdpType = RPacketContext::EPdpTypeIPv4;

   772 	setConfig99.iPdpAddress.Copy(KPdpAdd99);

   773 	setConfig99.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);

   774 	setConfig99.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);

   775 	setConfig99.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;

   776 	setConfig99.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);

   777 	setConfig99.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);

   778 	setConfig99.iProtocolConfigOption.iId = KRequestID;

   779 	TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig99(setConfig99);

   780 

   781 	// Create the PCO buffer

   782 	RPacketContext::TMiscProtocolBuffer pcoBuffer;

   783 	pcoBuffer.Zero();

   784 

   785 	// Generate a PCO buffer

   786 	PCOGeneratorL(setConfig99.iProtocolConfigOption, pcoBuffer);

   787 	setConfig99.iProtocolConfigOption.iId = KRequestID;

   788 

   789 	//

   790 	// 99 Configuration

   791 	RPacketQoS::TQoSR99_R4Requested qosExpectedRequested99Profile;

   792 

   793 	DriverInitialiseContextL();

   794 	DriverSetConfigContextL(contextId, setConfig99.iAccessPointName, setConfig99.iPdpType, setConfig99.iPdpAddress, pcoBuffer);

   795 	RBuf8 data;

   796 	CleanupClosePushL(data);

   797 

   798 	TMockLtsyData2<TInfoName, RPacketQoS::TQoSR99_R4Requested> packetSetConfig99Data(contextId,qosExpectedRequested99Profile);

   799 	data.Close();

   800 	packetSetConfig99Data.SerialiseL(data);

   801 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosR99R4::KLtsyDispatchPacketServicesSetPdpContextQosR99R4ApiId, data, KErrNone);

   802 

   803 	TMockLtsyData1<TInfoName> callbackSetPdp99ContextNameData(contextId);

   804 	callbackSetPdp99ContextNameData.SerialiseL(data);

   805 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosR99R4::KLtsyDispatchPacketServicesSetPdpContextQosR99R4ApiId, KErrNone, data);

   806 

   807 	//Activate

   808 	TMockLtsyData1<TInfoName> expectedActivateContextNameData(contextId);

   809 	data.Close();

   810 	expectedActivateContextNameData.SerialiseL(data);

   811 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, data, KErrNone);

   812 

   813 	TMockLtsyData3<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolType>

   814 		completedActivateContextNameData(contextId, setConfig99.iAccessPointName, setConfig99.iPdpType);

   815 	data.Close();

   816 	completedActivateContextNameData.SerialiseL(data);

   817 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, KErrNone, data);

   818 

   819 	RPacketQoS::TQoSR99_R4Negotiated completedProfile;

   820 	TMockLtsyData2<TInfoName, RPacketQoS::TQoSR99_R4Negotiated> expLtsyQosProfileChangedInd(contextId, completedProfile);

   821 	data.Close();

   822 	expLtsyQosProfileChangedInd.SerialiseL(data);

   823 	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyQosProfileChangedIndId, KErrNone, data);

   824 

   825 	// Prepare context configuration for 99

   826 	RPacketContext::TContextConfigR99_R4 setConfig99Active;

   827 	setConfig99Active.iAccessPointName.Copy(KPointName99);

   828 	setConfig99Active.iPdpType = RPacketContext::EPdpTypeIPv4;

   829 	setConfig99Active.iPdpAddress.Copy(KAddress);

   830 	TUint pdpCompression = 0;

   831 

   832 	TMockLtsyData5<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolAddress, TUint, RPacketContext::TMiscProtocolBuffer>

   833 					expLtsyProfileChangedInd(contextId, setConfig99Active.iAccessPointName,

   834 					setConfig99Active.iPdpAddress, pdpCompression, pcoBuffer);

   835 	data.Close();

   836 	expLtsyProfileChangedInd.SerialiseL(data);

   837 	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyPdpContextConfigChangedIndId, KErrNone, data);

   838 

   839 	

   840 

   841 	//

   842 

   843 	// client side test

   844 	RPacketContext packetContext;

   845 

   846 	// Open a new context

   847 	TInt err = packetContext.OpenNewContext(packetService, contextId);

   848 	CleanupClosePushL(packetContext);

   849 	ASSERT_EQUALS(KErrNone, err);

   850 

   851 	RPacketContext::TDataChannelV2 dataChannel;

   852 	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);

   853 	TRequestStatus initialiseContextStatus;

   854 

   855 	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);

   856 	User::WaitForRequest(initialiseContextStatus);

   857 

   858 	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());

   859 	ASSERT_TRUE(dataChannel.iPort == KFirstAllocatedContextName);	

   860 	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId); // Now deprecated

   861 

   862 	TRequestStatus setConfigStatus;

   863 	packetContext.SetConfig(setConfigStatus, pckgConfig99);

   864 	User::WaitForRequest(setConfigStatus);

   865 	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());

   866 

   867 	TName qosName;

   868 	RPacketQoS packetQoS;

   869 	packetQoS.OpenNewQoS(packetContext, qosName);

   870 	CleanupClosePushL(packetQoS);

   871 

   872 	//

   873     // SetProfileParameters for 99 Configurations

   874     //

   875 

   876 	RPacketQoS::TQoSR99_R4Requested qos99RequestedProfile;

   877 	TPckg< RPacketQoS::TQoSR99_R4Requested > profilePckg99(qos99RequestedProfile);

   878 

   879 	

   880 	//

   881 

   882 	TRequestStatus notifyProfileChangeStatus;

   883 	RPacketQoS::TQoSR99_R4Negotiated profile;

   884 	TPckg<RPacketQoS::TQoSR99_R4Negotiated> qos99NegotiatedProfilePk(profile);

   885 	packetQoS.NotifyProfileChanged(notifyProfileChangeStatus, qos99NegotiatedProfilePk);

   886 	

   887 	TRequestStatus requestStatus99;

   888 	packetQoS.SetProfileParameters(requestStatus99, profilePckg99);

   889 	User::WaitForRequest(requestStatus99);

   890 	ASSERT_EQUALS(KErrNone, requestStatus99.Int());

   891 

   892 	RPacketContext::TContextConfigR99_R4 setConfig99ActiveNotifyConfigChanged;

   893 	TPckg<RPacketContext::TContextConfigR99_R4> pckgConfig99NotifyConfigChanged(setConfig99ActiveNotifyConfigChanged);

   894 

   895 	TRequestStatus contextConfigStatus;

   896 	packetContext.NotifyConfigChanged(contextConfigStatus, pckgConfig99NotifyConfigChanged);

   897 

   898 	TRequestStatus contextActivatingRequestStatus;

   899 	RPacketContext::TContextStatus contextStatus;

   900 	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);

   901 

   902 	TRequestStatus activateStatus;

   903 	packetContext.Activate(activateStatus);

   904 	User::WaitForRequest(activateStatus);

   905 	User::WaitForRequest(contextActivatingRequestStatus);

   906 	ASSERT_EQUALS(KErrNone, activateStatus.Int());

   907 	ASSERT_EQUALS(RPacketContext::EStatusActivating, contextStatus);

   908 

   909 	// Complete NotifyProfileChanged

   910 	User::WaitForRequest(notifyProfileChangeStatus);

   911 	ASSERT_EQUALS(KErrNone, notifyProfileChangeStatus.Int());

   912 

   913 	// Status change from RPacketContext::EStatusActivating to RPacketContext::EStatusActive

   914 	TRequestStatus contextActivateRequestStatus;

   915 	RPacketContext::TContextStatus contextActiveStatus;

   916 	packetContext.NotifyStatusChange(contextActivateRequestStatus, contextActiveStatus);

   917 

   918 	// Complete NotifyConfigChanged

   919 	//User::WaitForRequest(contextConfigStatus);

   920 	User::WaitForRequest(contextActivateRequestStatus);

   921 	//ASSERT_EQUALS(KErrNone, contextConfigStatus.Int());

   922 	ASSERT_EQUALS(KErrNone, contextActivateRequestStatus.Int());

   923 	ASSERT_EQUALS(RPacketContext::EStatusActive, contextActiveStatus);

   924 

   925 	DriverDeleteContextL(contextId);

   926 	packetQoS.Close();

   927 	packetContext.Close();

   928 	packetService.Close();

   929 

   930 	// Let the mock-LTSY finish up before asserting.

   931 	User::After(1000000);

   932 	

   933 	AssertMockLtsyStatusL();

   934 	CleanupStack::PopAndDestroy(5, this); // data, packetQoS, packetService, packetContext, this

   935 	}

   936 

   937 /**

   938 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-UC0004

   939 @SYMComponent telephony_ctsy

   940 @SYMTestCaseDesc Test support in CTSY for modification of an existing context

   941 @SYMTestPriority High

   942 @SYMTestActions Invokes RPacketContext::SetConfig(), RPacketContext::ModifyActiveContext()

   943 @SYMTestExpectedResults Pass

   944 @SYMTestType CT

   945  */

   946 void CCTsyPacketServicesFU::TestUseCase0004L()

   947 	{

   948 	OpenEtelServerL(EUseExtendedError);

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

   950 	OpenPhoneL();

   951 

   952 	RPacketService packetService;

   953 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

   954 

   955 	// Prepare context configuration fo GPRS

   956 	RPacketContext::TContextConfigGPRS setConfigGPRS;

   957 	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);

   958 	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;

   959 	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);

   960 	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);

   961 	setConfigGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);

   962 	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;

   963 	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);

   964 	setConfigGPRS.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);

   965 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

   966 	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS(setConfigGPRS);

   967 

   968 	// Create the PCO buffer

   969 	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;

   970 	gprsMiscBuffer.Zero();

   971 

   972 	// Generate a PCO buffer

   973 	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);

   974 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

   975 

   976 	//

   977 

   978 	DriverInitialiseContextL();

   979 

   980 	// GPRS Configuration

   981 	TInfoName contextName;

   982 	contextName.Copy(KFirstAllocatedContextName);

   983 

   984 	DriverSetConfigContextL(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType,

   985 			setConfigGPRS.iPdpAddress, gprsMiscBuffer);

   986 

   987 	RPacketQoS::TQoSGPRSRequested qosExpectedRequestedGPRSProfile;

   988 

   989 	qosExpectedRequestedGPRSProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   990 	qosExpectedRequestedGPRSProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   991 	qosExpectedRequestedGPRSProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;

   992 	qosExpectedRequestedGPRSProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;

   993 	qosExpectedRequestedGPRSProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;

   994 	qosExpectedRequestedGPRSProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;

   995 	qosExpectedRequestedGPRSProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   996 	qosExpectedRequestedGPRSProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   997 	qosExpectedRequestedGPRSProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

   998 	qosExpectedRequestedGPRSProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

   999 

  1000 	RBuf8 data;

  1001 	CleanupClosePushL(data);

  1002 	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSRequested> packetSetConfigGPRSData(contextName,

  1003 			qosExpectedRequestedGPRSProfile);

  1004 	data.Close();

  1005 	packetSetConfigGPRSData.SerialiseL(data);

  1006 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, data, KErrNone);

  1007 

  1008 	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextName);

  1009 	data.Close();

  1010 	callbackSetPdpGPRSContextNameData.SerialiseL(data);

  1011 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, KErrNone, data);

  1012 

  1013 	//Activate

  1014 	TMockLtsyData1<TInfoName> expectedActivateContextNameData(contextName);

  1015 	data.Close();

  1016 	expectedActivateContextNameData.SerialiseL(data);

  1017 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, data, KErrNone);

  1018 

  1019 	TMockLtsyData3<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolType>

  1020 	completedActivateContextNameData(contextName, setConfigGPRS.iAccessPointName, setConfigGPRS.iPdpType);

  1021 	data.Close();

  1022 	completedActivateContextNameData.SerialiseL(data);

  1023 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, KErrNone, data);

  1024 

  1025 	RPacketQoS::TQoSGPRSNegotiated completedProfile;

  1026 	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSNegotiated>

  1027 				expLtsyQosProfileChangedInd(contextName, completedProfile);

  1028 	data.Close();

  1029 	expLtsyQosProfileChangedInd.SerialiseL(data);

  1030 	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyQosProfileChangedIndId, KErrNone, data);

  1031 

  1032 	// Prepare context configuration for GPRS

  1033 	RPacketContext::TContextConfigGPRS setConfigGPRSActive;

  1034 	setConfigGPRSActive.iAccessPointName.Copy(KPointNameGPRS);

  1035 	setConfigGPRSActive.iPdpType = RPacketContext::EPdpTypeIPv6;

  1036 	setConfigGPRSActive.iPdpAddress.Copy(KPdpAddGPRS);

  1037 	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDns);

  1038 	setConfigGPRSActive.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDns);

  1039 	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP;

  1040 	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername);

  1041 	setConfigGPRSActive.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword);

  1042 

  1043 	TMockLtsyData5<TInfoName, RPacketContext::TGSNAddress, RPacketContext::TProtocolAddress, TUint, RPacketContext::TMiscProtocolBuffer>

  1044 					expLtsyProfileChangedInd(contextName, setConfigGPRS.iAccessPointName,

  1045 							setConfigGPRS.iPdpAddress, setConfigGPRS.iPdpCompression, gprsMiscBuffer);

  1046 	data.Close();

  1047 	expLtsyProfileChangedInd.SerialiseL(data);

  1048 

  1049 	iMockLTSY.CompleteL(KMockLtsyDispatchPacketServicesNotifyPdpContextConfigChangedIndId, KErrNone, data);

  1050 

  1051 

  1052 	DriverSetConfigContextL(contextName, setConfigGPRSActive.iAccessPointName, setConfigGPRSActive.iPdpType,

  1053 			setConfigGPRSActive.iPdpAddress, gprsMiscBuffer);

  1054 

  1055 	DriverModifyActiveContextL(KRejectionCodePass, KErrNone);

  1056 	DriverModifyActiveContextL(KRejectionCodeFail, KErrGeneral);

  1057 

  1058 	TMockLtsyData1<TInfoName> deactivateContextNameData(contextName);

  1059 	data.Close();

  1060 	deactivateContextNameData.SerialiseL(data);

  1061 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, data, KErrNone);

  1062 	iMockLTSY.CompleteL(MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, KErrNone, data);

  1063 

  1064 	DriverDeleteContextL(contextName);

  1065 

  1066 	//

  1067 

  1068 	// client side test

  1069 	RPacketContext packetContext;

  1070 

  1071 	// Open a new context

  1072 	TInt err = packetContext.OpenNewContext(packetService, contextName);

  1073 	CleanupClosePushL(packetContext);

  1074 	ASSERT_EQUALS(KErrNone, err);

  1075 

  1076 	RPacketContext::TDataChannelV2 dataChannel;

  1077 	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);

  1078 	TRequestStatus initialiseContextStatus;

  1079 

  1080 	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);

  1081 	User::WaitForRequest(initialiseContextStatus);

  1082 

  1083 	ASSERT_EQUALS(KErrNone, initialiseContextStatus.Int());

  1084 	ASSERT_TRUE(dataChannel.iPort == KFirstAllocatedContextName);	

  1085 	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId); // Now deprecated

  1086 

  1087 	TRequestStatus setConfigStatus;

  1088 	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);

  1089 

  1090 	User::WaitForRequest(setConfigStatus);

  1091 	ASSERT_EQUALS(KErrNone, setConfigStatus.Int());

  1092 

  1093 	TName qosName;

  1094 	RPacketQoS packetQoS;

  1095 	packetQoS.OpenNewQoS(packetContext, qosName);

  1096 	CleanupClosePushL(packetQoS);

  1097 

  1098 	//

  1099     // SetProfileParameters for GPRS Configurations

  1100     //

  1101 

  1102 	RPacketQoS::TQoSGPRSRequested qosGPRSRequestedProfile;

  1103 	qosGPRSRequestedProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;

  1104 	qosGPRSRequestedProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;

  1105 	qosGPRSRequestedProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;

  1106 	qosGPRSRequestedProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;

  1107 	qosGPRSRequestedProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;

  1108 	qosGPRSRequestedProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;

  1109 	qosGPRSRequestedProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

  1110 	qosGPRSRequestedProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

  1111 	qosGPRSRequestedProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

  1112 	qosGPRSRequestedProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

  1113 	TPckg< RPacketQoS::TQoSGPRSRequested > profilePckgGPRS(qosGPRSRequestedProfile);

  1114 

  1115 	TRequestStatus notifyProfileChangeStatus;

  1116 	RPacketQoS::TQoSGPRSNegotiated profile;

  1117 	TPckg<RPacketQoS::TQoSGPRSNegotiated> qosGPRSNegotiatedProfilePk(profile);

  1118 	packetQoS.NotifyProfileChanged(notifyProfileChangeStatus, qosGPRSNegotiatedProfilePk);

  1119 

  1120 	TRequestStatus requestStatusGPRS;

  1121 	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);

  1122 	User::WaitForRequest(requestStatusGPRS);

  1123 	ASSERT_EQUALS(KErrNone, requestStatusGPRS.Int());

  1124 

  1125 	//

  1126 

  1127 	RPacketContext::TContextConfigGPRS setConfigGPRSActiveNotifyConfigChanged;

  1128 	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRSNotifyConfigChanged(setConfigGPRSActiveNotifyConfigChanged);

  1129 

  1130 	TRequestStatus contextConfigStatus;

  1131 	packetContext.NotifyConfigChanged(contextConfigStatus, pckgConfigGPRSNotifyConfigChanged);

  1132 

  1133 	TRequestStatus contextActivatingRequestStatus;

  1134 	RPacketContext::TContextStatus contextStatus;

  1135 	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);