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 CallControl in the Common TSY.

    20 */

    21 

    22 #include <etel.h>

    23 #include <etelmm.h>

    24 #include <et_clsvr.h>

    25 #include <ctsy/mmtsy_names.h>

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

    27 #include <test/tmockltsydata.h>

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

    29 

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

    31 #include "config.h"

    32 #include "mockltsyindicatorids.h"

    33 #include <in_sock.h>

    34 

    35 #include "cctsypacketservicesfunegative.h"

    36 

    37 void CCTsyPacketServicesFUNegative::ConvertDNSToPCOBuffer

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

    39 	{

    40 	// Handle Primary DNS address

    41 	TInetAddr netPrimaryDNS;

    42 	TBuf<KDnsLength> netPrimaryDNSConv;

    43 	netPrimaryDNSConv.Copy(aPrimaryDNS);

    44 	netPrimaryDNS.Input(netPrimaryDNSConv);

    45 	TUint32 primDNSaddr =  netPrimaryDNS.Address();

    46 

    47 	// Handle Secondary DNS address

    48 	TInetAddr netSecondaryDNS;

    49 	TBuf<KDnsLength> netSecondaryDNSConv;

    50 	netSecondaryDNSConv.Copy(aSecondaryDNS);

    51 	netSecondaryDNS.Input(netSecondaryDNSConv);

    52 	TUint32 secondaryDNSaddr =  netSecondaryDNS.Address();

    53 

    54 	aFormatPcoBufferAddr[0] = KPrimaryAndSecondaryDNSLength;	// Length

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    71 	aFormatPcoBufferAddr.SetLength(KPrimaryAndSecondaryDNSLength + 1);

    72 	}

    73 

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

    75 void CCTsyPacketServicesFUNegative::ConvertUsernameAndPasswordToPCOBuffer(const TDes8& aUsername, 

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

    77 	{

    78 	TInt usernameLen = aUsername.Length();

    79 	TInt passwordLen = aPassword.Length();

    80 	TInt dataLen = usernameLen + passwordLen + KPasswordUsernameHeaderLength;

    81 	TInt i = 0;

    82 

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

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

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

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

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

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

    89 	aFormatedBuffer.SetLength(i);

    90 	aFormatedBuffer.Append(aUsername); 				// Username

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

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

    93 	aFormatedBuffer.Append(aPassword);				// Password

    94 	}

    95 

    96 /***

    97 * 											PCO - Description

    98 *

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

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

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

   102 * or an application.

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

   104 * octets and a maximum length of 253 octets

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

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

   107 *  

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

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

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

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

   112 * (The dispatcher handles the overflow scenario). 

   113 *

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

   115 *	

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   151 *   

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

   153 *   example above).      

   154 */

   155  

   156 // 

   157 //

   158 //

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

   160 void CCTsyPacketServicesFUNegative::PCOGeneratorL(RPacketContext::TProtocolConfigOptionV2& aPco, RPacketContext::TMiscProtocolBuffer& aPcoBuffer)

   161 	{

   162 

   163 	TBuf8<KMaxUserAndPassLength> userAndPasswordBuffer(KMaxUserAndPassLength);

   164 

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

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

   167 

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

   169 			userAndPasswordBuffer.Length(), userAndPasswordBuffer.Length());

   170 

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

   172 

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

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

   175 

   176 	// Setting the configurations buffers

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

   178 				primaryAndSecondaryDNSBuffer.Length(), primaryAndSecondaryDNSBuffer.Length());

   179 

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

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

   182 

   183 	RPacketContext::TPcoId usenameAndPasswordID(KUsenamePasswordDNSID);

   184 	RPacketContext::TPcoId primaryAndSecondaryDNSID(KPrimaryAndSecondaryDNSID);

   185 

   186 	pcoTlv.AppendItemL(usenameAndPasswordID, userAndPasswordParamDataPtr);

   187 	pcoTlv.AppendItemL(primaryAndSecondaryDNSID, primaryAndSecondaryDNSParamDataPtr);

   188 

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

   190 

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

   192 	aPcoBuffer.Append(aPco.iMiscBuffer);

   193 	}

   194 

   195 void CCTsyPacketServicesFUNegative::DriverDeleteContextL(TInfoName aContextName)

   196 	{

   197 	RBuf8 data;

   198 	CleanupClosePushL(data);

   199 	TMockLtsyData1<TInfoName> contextNameData(aContextName);

   200 	data.Close();

   201 	contextNameData.SerialiseL(data);

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

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

   204 	}

   205 

   206 void CCTsyPacketServicesFUNegative::DriverAttachPacketServiceL()

   207 	{

   208 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId);

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

   210 	}

   211 

   212 void CCTsyPacketServicesFUNegative::DriverDetachPacketServiceL()

   213 	{

   214 	iMockLTSY.ExpectL(MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId);

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

   216 

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

   218 	RBuf8 dataExpect;

   219     CleanupClosePushL(dataExpect);

   220     RPacketService::TAttachMode attachMode = RPacketService::EAttachWhenPossible;

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

   222     dataExpect.Close();

   223     ltsyData.SerialiseL(dataExpect);

   224 

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

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

   227 

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

   229 	}

   230 

   231 void CCTsyPacketServicesFUNegative::DriverInitialiseContextL()

   232 	{

   233 	RBuf8 data;

   234 	CleanupClosePushL(data);

   235 

   236 	TInfoName primaryContext;

   237 	TInfoName secondaryContext;

   238 	primaryContext.Copy(KFirstAllocatedContextName);

   239 	secondaryContext.Copy(KDefaultContextName);

   240 

   241 	//-------------------------------------------------------------------------

   242 	// Successful completion request of

   243 	// RPacketContext::InitialiseContext

   244  	//-------------------------------------------------------------------------

   245 

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

   247 	data.Close();

   248 	expLtsyContextNamesData3.SerialiseL(data);

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

   250 

   251 	TDesC* contextNamePtr = &primaryContext;

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

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

   254 	data.Close();

   255 	expLtsyContextNameAndChannelIdData.SerialiseL(data);

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

   257 

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

   259 	}

   260 

   261 void CCTsyPacketServicesFUNegative::DriverInitialiseContextL(const TInfoName& aPrimaryContextId, const TInfoName& aSecondaryContextId)

   262 	{

   263 	RBuf8 data;

   264 	CleanupClosePushL(data);

   265 

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

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

   268 

   269 	//-------------------------------------------------------------------------

   270 	// Successful completion request of

   271 	// RPacketContext::InitialiseContext

   272  	//-------------------------------------------------------------------------

   273 

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

   275 	data.Close();

   276 	expLtsyContextNamesData.SerialiseL(data);

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

   278 

   279 

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

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

   282 	

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

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

   285 	data.Close();

   286 	expLtsyContextNameAndPortData2.SerialiseL(data);	

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

   288 

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

   290 	}

   291 

   292 void CCTsyPacketServicesFUNegative::DriverSetConfigContextL(TInfoName aContextId,

   293 		RPacketContext::TGSNAddress aAccessPoint, RPacketContext::TProtocolType aPdpType, 

   294 		RPacketContext::TProtocolAddress aPdpAddress,

   295 		RPacketContext::TMiscProtocolBuffer aPcoBuffer)

   296 	{

   297 

   298 	RBuf8 data;

   299 	CleanupClosePushL(data);

   300 

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

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

   303 	data.Close();

   304 	packetSetConfigData.SerialiseL(data);

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

   306 

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

   308 	TInfoName callbackContextId = aContextId;

   309 	TMockLtsyData1<TInfoName> callbackContextIdData(callbackContextId);

   310 	data.Close();

   311 	callbackContextIdData.SerialiseL(data);

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

   313 

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

   315 	}

   316 

   317 void CCTsyPacketServicesFUNegative::DriverModifyActiveContextL(TInt8 aRejectionCode, TInt aError)

   318 	{

   319 	RBuf8 data;

   320 	CleanupClosePushL(data);

   321 

   322 	TInfoName modifyActiveContextName;

   323 	modifyActiveContextName.Copy(KFirstAllocatedContextName);

   324 	TMockLtsyData1<TInfoName>

   325 		modifyActiveContextNameData(modifyActiveContextName);

   326 	data.Close();

   327 	modifyActiveContextNameData.SerialiseL(data);

   328 

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

   330 

   331 	TMockLtsyData2<TInfoName, TInt8 >

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

   333 	data.Close();

   334 	completeModifyActiveContextData.SerialiseL(data);

   335 

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

   337 

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

   339 	}

   340 

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

   342 	{

   343 	aPacketContext.OpenNewContext(aPacketService, aContextName);

   344 	CleanupClosePushL(aPacketContext);

   345 

   346 	RBuf8 data;

   347 	CleanupClosePushL(data);

   348 	

   349 	TDesC* contextNamePtr = &aContextName;

   350 	TMockLtsyData1<TDesC*> initMbmdContextExpData(contextNamePtr);

   351 	initMbmdContextExpData.SerialiseL(data);

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

   353 	data.Close();

   354 	

   355 	

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

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

   358 	initMbmdContextCompData.SerialiseL(data);

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

   360 	data.Close();

   361 	

   362 	//initialisation of the context

   363 	RPacketContext::TDataChannelV2 dataChannel;

   364 	RPacketContext::TDataChannelV2Pckg dataChannelPckg(dataChannel);

   365 

   366 	TRequestStatus requestStatus;

   367     aPacketContext.InitialiseContext(requestStatus, dataChannelPckg);

   368 	User::WaitForRequest(requestStatus);

   369 	ASSERT_EQUALS(requestStatus.Int(), aCompError);

   370 	ASSERT_TRUE((aCompError != KErrNone) || (dataChannel.iChannelId == aChannelId));

   371 	

   372 	AssertMockLtsyStatusL();

   373 	

   374 	CleanupStack::PopAndDestroy(&data);

   375 	}

   376 

   377 CTestSuite* CCTsyPacketServicesFUNegative::CreateSuiteL(const TDesC& aName)

   378 	{

   379 	SUB_SUITE;

   380   	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0001L);

   381 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0002L);

   382 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0003L);

   383 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0004L);	

   384 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0005L);

   385 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0006L);

   386 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0007L);

   387 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0008L);

   388 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0009L);

   389 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0010L);

   390 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0011L);

   391 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0012L);

   392 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0013L);

   393 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0014L);

   394 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0015L);

   395 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0016L);

   396 

   397 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0018L);

   398 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0019L);

   399 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0020L);

   400 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0021L);

   401 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0022L);

   402 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0023L);

   403 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0024L);

   404 	ADD_TEST_STEP_ISO_CPP(CCTsyPacketServicesFUNegative, TestUnit0025L);

   405 	END_SUITE;

   406 	}

   407 

   408 //

   409 // 'Negative' unit tests

   410 //

   411 

   412 /**

   413 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0001

   414 @SYMComponent telephony_ctsy

   415 @SYMTestCaseDesc Test returned value if EPacketAttach is not supported by LTSY

   416 @SYMTestPriority High

   417 @SYMTestActions Invokes RPacketService::Attach()

   418 @SYMTestExpectedResults Pass

   419 @SYMTestType UT

   420 */

   421 void CCTsyPacketServicesFUNegative::TestUnit0001L()

   422 	{

   423 	TConfig config;

   424 	config.SetSupportedValue(MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId, EFalse);

   425 	

   426 	OpenEtelServerL(EUseExtendedError);

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

   428 	OpenPhoneL();

   429 	

   430 	TRequestStatus requestStatus;

   431 	RPacketService packetService;

   432 	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

   433 

   434     packetService.Attach(requestStatus);

   435 	User::WaitForRequest(requestStatus);

   436 

   437 	ASSERT_EQUALS(KErrGsmMMNetworkFailure, requestStatus.Int());

   438 	

   439 	packetService.Close();

   440 	AssertMockLtsyStatusL();

   441 	config.Reset();

   442 	CleanupStack::PopAndDestroy(2, this); // packetService, this

   443 	}

   444 

   445 /**

   446 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0002

   447 @SYMComponent telephony_ctsy

   448 @SYMTestCaseDesc Test returned value if EPacketGetAttachMode is not supported by LTSY

   449 @SYMTestPriority High

   450 @SYMTestActions Invokes RPacketService::GetAttachMode()

   451 @SYMTestExpectedResults Pass

   452 @SYMTestType UT

   453 */

   454 void CCTsyPacketServicesFUNegative::TestUnit0002L()

   455 	{

   456 	TConfig config;

   457 	config.SetSupportedValue(MLtsyDispatchPacketServicesGetPacketAttachMode::KLtsyDispatchPacketServicesGetPacketAttachModeApiId, EFalse);

   458 	

   459 	OpenEtelServerL(EUseExtendedError);

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

   461 	OpenPhoneL();

   462 	

   463 	TRequestStatus requestStatus;

   464 	RPacketService packetService;

   465 	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

   466 	

   467 	RPacketService::TAttachMode completedAttachMode;

   468 	

   469 	packetService.GetAttachMode(requestStatus, completedAttachMode);

   470 	User::WaitForRequest(requestStatus);

   471 	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

   472 

   473 	packetService.Close();

   474 	AssertMockLtsyStatusL();

   475 	config.Reset();

   476 	CleanupStack::PopAndDestroy(2, this); // packetService, this

   477 	}

   478 

   479 /**

   480 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0003

   481 @SYMComponent telephony_ctsy

   482 @SYMTestCaseDesc Test returned value if EPacketGetNtwkRegStatus is not supported by LTSY

   483 @SYMTestPriority High

   484 @SYMTestActions Invokes RPacketService::GetNtwkRegStatus()

   485 @SYMTestExpectedResults Pass

   486 @SYMTestType UT

   487 */

   488 void CCTsyPacketServicesFUNegative::TestUnit0003L()

   489 	{

   490 	TConfig config;

   491 	config.SetSupportedValue(MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus::KLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatusApiId, EFalse);

   492 	

   493 	OpenEtelServerL(EUseExtendedError);

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

   495 	OpenPhoneL();

   496 	

   497 	TRequestStatus requestStatus;

   498 	RPacketService packetService;

   499 	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

   500 	

   501 	RPacketService::TRegistrationStatus registrationStatus;

   502 

   503 	packetService.GetNtwkRegStatus(requestStatus, registrationStatus);

   504 	User::WaitForRequest(requestStatus);

   505 	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

   506 

   507 	packetService.Close();

   508 	AssertMockLtsyStatusL();

   509 	config.Reset();

   510 	CleanupStack::PopAndDestroy(2, this); // packetService, this

   511 	}

   512 

   513 /**

   514 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0004

   515 @SYMComponent telephony_ctsy

   516 @SYMTestCaseDesc Test returned value if EPacketDetach is not supported by LTSY

   517 @SYMTestPriority High

   518 @SYMTestActions Invokes RPacketService::Detach()

   519 @SYMTestExpectedResults Pass

   520 @SYMTestType UT

   521 */

   522 void CCTsyPacketServicesFUNegative::TestUnit0004L()

   523 	{

   524 	TConfig config;

   525 	config.SetSupportedValue(MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId, EFalse);

   526 	

   527 	OpenEtelServerL(EUseExtendedError);

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

   529 	OpenPhoneL();

   530 

   531 	RPacketService packetService;

   532 	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

   533 	

   534     TRequestStatus mockLtsyStatus;

   535     iMockLTSY.NotifyTerminated(mockLtsyStatus);

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

   537     User::WaitForRequest(mockLtsyStatus);

   538     AssertMockLtsyStatusL();

   539     

   540     TRequestStatus requestStatus;

   541     packetService.Detach(requestStatus);

   542     User::WaitForRequest(requestStatus);

   543     AssertMockLtsyStatusL();

   544     ASSERT_EQUALS(KErrGsmMMNetworkFailure, requestStatus.Int());

   545 

   546 	packetService.Close();

   547 	AssertMockLtsyStatusL();

   548 	config.Reset();

   549 	CleanupStack::PopAndDestroy(2, this); // packetService, this

   550 	}

   551 

   552 /**

   553 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0005

   554 @SYMComponent telephony_ctsy

   555 @SYMTestCaseDesc Test returned value if EPacketContextSetConfig is not supported by LTSY

   556 @SYMTestPriority High

   557 @SYMTestActions Invokes RPacketContext::SetConfig()

   558 @SYMTestExpectedResults Pass

   559 @SYMTestType UT

   560 */

   561 void CCTsyPacketServicesFUNegative::TestUnit0005L()

   562 	{

   563 	TConfig config;

   564 	config.SetSupportedValue(MLtsyDispatchPacketServicesSetPdpContextConfig::KLtsyDispatchPacketServicesSetPdpContextConfigApiId, EFalse);

   565 

   566 	OpenEtelServerL(EUseExtendedError);

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

   568 	OpenPhoneL();

   569 

   570 	RPacketService packetService;

   571 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

   572 

   573 	// Prepare context configuration fo GPRS

   574 	RPacketContext::TContextConfigGPRS setConfigGPRS;

   575 	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);

   576 	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;

   577 	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);

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

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

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

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

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

   583 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

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

   585 

   586 	// Create the PCO buffer

   587 	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;

   588 	gprsMiscBuffer.Zero();

   589 

   590 	// Generate a PCO buffer

   591 	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);

   592 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

   593 

   594 	//

   595 

   596 	DriverInitialiseContextL();

   597 

   598 	// GPRS Configuration

   599 	TInfoName contextName;

   600 	contextName.Copy(KFirstAllocatedContextName);

   601 

   602 	DriverDeleteContextL(contextName);

   603 

   604 	//

   605 

   606 	// client side test

   607 	RPacketContext packetContext;

   608 

   609 	// Open a new context

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

   611 	CleanupClosePushL(packetContext);

   612 	ASSERT_EQUALS(KErrNone, err);

   613 

   614 	RPacketContext::TDataChannelV2 dataChannel;

   615 	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);

   616 	TRequestStatus initialiseContextStatus;

   617 

   618 	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);

   619 	User::WaitForRequest(initialiseContextStatus);

   620 

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

   622 	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);

   623 

   624 	TRequestStatus setConfigStatus;

   625 

   626 	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);

   627 	User::WaitForRequest(setConfigStatus);

   628 	ASSERT_EQUALS(KErrNotSupported, setConfigStatus.Int());

   629 

   630 	packetContext.Close();

   631 	packetService.Close();

   632 	AssertMockLtsyStatusL();

   633 	config.Reset();

   634 	CleanupStack::PopAndDestroy(3, this); // packetContext, packetService, this

   635 	}

   636 

   637 /**

   638 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0006

   639 @SYMComponent telephony_ctsy

   640 @SYMTestCaseDesc Test returned value if EPacketContextModifyActiveContext is not supported by LTSY

   641 @SYMTestPriority High

   642 @SYMTestActions Invokes RPacketContext::ModifyActiveContext()

   643 @SYMTestExpectedResults Pass

   644 @SYMTestType UT

   645 */

   646 void CCTsyPacketServicesFUNegative::TestUnit0006L()

   647 	{

   648 	TConfig config;

   649 	config.SetSupportedValue(MLtsyDispatchPacketServicesModifyActivePdpContext::KLtsyDispatchPacketServicesModifyActivePdpContextApiId, EFalse);

   650 

   651 	OpenEtelServerL(EUseExtendedError);

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

   653 	OpenPhoneL();

   654 	

   655 	RPacketService packetService;

   656 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

   657 

   658 	// Prepare context configuration fo GPRS

   659 	RPacketContext::TContextConfigGPRS setConfigGPRS;

   660 	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);

   661 	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;

   662 	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);

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

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

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

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

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

   668 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

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

   670 

   671 	// Create the PCO buffer

   672 	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;

   673 	gprsMiscBuffer.Zero();

   674 

   675 	// Generate a PCO buffer

   676 	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);

   677 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

   678 

   679 	//

   680 

   681 	DriverInitialiseContextL();

   682 

   683 	// GPRS Configuration

   684 	TInfoName contextName;

   685 	contextName.Copy(KFirstAllocatedContextName);

   686 

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

   688 			setConfigGPRS.iPdpAddress, gprsMiscBuffer);

   689 

   690 	RPacketQoS::TQoSGPRSRequested qosExpectedRequestedGPRSProfile;

   691 

   692 	qosExpectedRequestedGPRSProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   693 	qosExpectedRequestedGPRSProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   694 	qosExpectedRequestedGPRSProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;

   695 	qosExpectedRequestedGPRSProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;

   696 	qosExpectedRequestedGPRSProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;

   697 	qosExpectedRequestedGPRSProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;

   698 	qosExpectedRequestedGPRSProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   699 	qosExpectedRequestedGPRSProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   700 	qosExpectedRequestedGPRSProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

   701 	qosExpectedRequestedGPRSProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

   702 

   703 	RBuf8 data;

   704 	CleanupClosePushL(data);

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

   706 			qosExpectedRequestedGPRSProfile);

   707 	data.Close();

   708 	packetSetConfigGPRSData.SerialiseL(data);

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

   710 

   711 	TMockLtsyData1<TInfoName> callbackSetPdpGPRSContextNameData(contextName);

   712 	data.Close();

   713 	callbackSetPdpGPRSContextNameData.SerialiseL(data);

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

   715 

   716 	//Activate

   717 	TMockLtsyData1<TInfoName> expectedActivateContextNameData(contextName);

   718 	data.Close();

   719 	expectedActivateContextNameData.SerialiseL(data);

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

   721 

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

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

   724 	data.Close();

   725 	completedActivateContextNameData.SerialiseL(data);

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

   727 

   728 	RPacketQoS::TQoSGPRSNegotiated completedProfile;

   729 	TMockLtsyData2<TInfoName, RPacketQoS::TQoSGPRSNegotiated>

   730 				expLtsyQosProfileChangedInd(contextName, completedProfile);

   731 	data.Close();

   732 	expLtsyQosProfileChangedInd.SerialiseL(data);

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

   734 

   735 	// Prepare context configuration for GPRS

   736 	RPacketContext::TContextConfigGPRS setConfigGPRSActive;

   737 	setConfigGPRSActive.iAccessPointName.Copy(KPointNameGPRS);

   738 	setConfigGPRSActive.iPdpType = RPacketContext::EPdpTypeIPv6;

   739 	setConfigGPRSActive.iPdpAddress.Copy(KPdpAddGPRS);

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

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

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

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

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

   745 

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

   747 					expLtsyProfileChangedInd(contextName, setConfigGPRS.iAccessPointName,

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

   749 	data.Close();

   750 	expLtsyProfileChangedInd.SerialiseL(data);

   751 

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

   753 

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

   755 			setConfigGPRSActive.iPdpAddress, gprsMiscBuffer);

   756 

   757 	TMockLtsyData1<TInfoName> deactivateContextNameData(contextName);

   758 	data.Close();

   759 	deactivateContextNameData.SerialiseL(data);

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

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

   762 

   763 	DriverDeleteContextL(contextName);

   764 

   765 	//

   766 

   767 	// client side test

   768 	RPacketContext packetContext;

   769 

   770 	// Open a new context

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

   772 	CleanupClosePushL(packetContext);

   773 	ASSERT_EQUALS(KErrNone, err);

   774 

   775 	RPacketContext::TDataChannelV2 dataChannel;

   776 	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);

   777 	TRequestStatus initialiseContextStatus;

   778 

   779 	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);

   780 	User::WaitForRequest(initialiseContextStatus);

   781 

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

   783 	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);

   784 

   785 	TRequestStatus setConfigStatus;

   786 	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS);

   787 

   788 	User::WaitForRequest(setConfigStatus);

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

   790 

   791 	TName qosName;

   792 	RPacketQoS packetQoS;

   793 	packetQoS.OpenNewQoS(packetContext, qosName);

   794 	CleanupClosePushL(packetQoS);

   795 

   796 	//

   797     // SetProfileParameters for GPRS Configurations

   798     //

   799 

   800 	RPacketQoS::TQoSGPRSRequested qosGPRSRequestedProfile;

   801 	qosGPRSRequestedProfile.iReqPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   802 	qosGPRSRequestedProfile.iMinPrecedence = RPacketQoS::EUnspecifiedPrecedence;

   803 	qosGPRSRequestedProfile.iReqDelay = RPacketQoS::EUnspecifiedDelayClass;

   804 	qosGPRSRequestedProfile.iMinDelay = RPacketQoS::EUnspecifiedDelayClass;

   805 	qosGPRSRequestedProfile.iReqReliability = RPacketQoS::EUnspecifiedReliabilityClass;

   806 	qosGPRSRequestedProfile.iMinReliability = RPacketQoS::EUnspecifiedReliabilityClass;

   807 	qosGPRSRequestedProfile.iReqPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   808 	qosGPRSRequestedProfile.iMinPeakThroughput = RPacketQoS::EUnspecifiedPeakThroughput;

   809 	qosGPRSRequestedProfile.iReqMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

   810 	qosGPRSRequestedProfile.iMinMeanThroughput = RPacketQoS::EUnspecifiedMeanThroughput;

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

   812 

   813 	TRequestStatus notifyProfileChangeStatus;

   814 	RPacketQoS::TQoSGPRSNegotiated profile;

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

   816 	packetQoS.NotifyProfileChanged(notifyProfileChangeStatus, qosGPRSNegotiatedProfilePk);

   817 

   818 	TRequestStatus requestStatusGPRS;

   819 	packetQoS.SetProfileParameters(requestStatusGPRS, profilePckgGPRS);

   820 	User::WaitForRequest(requestStatusGPRS);

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

   822 

   823 	//

   824 

   825 	RPacketContext::TContextConfigGPRS setConfigGPRSActiveNotifyConfigChanged;

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

   827 

   828 	TRequestStatus contextConfigStatus;

   829 	packetContext.NotifyConfigChanged(contextConfigStatus, pckgConfigGPRSNotifyConfigChanged);

   830 

   831 	TRequestStatus contextActivatingRequestStatus;

   832 	RPacketContext::TContextStatus contextStatus;

   833 	packetContext.NotifyStatusChange(contextActivatingRequestStatus, contextStatus);

   834 

   835 	TRequestStatus activateStatus;

   836 	packetContext.Activate(activateStatus);

   837 	User::WaitForRequest(activateStatus);

   838 	User::WaitForRequest(contextActivatingRequestStatus);

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

   840 	ASSERT_EQUALS(RPacketContext::EStatusActivating, contextStatus);

   841 

   842 	// Complete NotifyProfileChanged

   843 	User::WaitForRequest(notifyProfileChangeStatus);

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

   845 

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

   847 	TRequestStatus contextActivateRequestStatus;

   848 	RPacketContext::TContextStatus contextActiveStatus;

   849 	packetContext.NotifyStatusChange(contextActivateRequestStatus, contextActiveStatus);

   850 

   851 	User::WaitForRequest(contextActivateRequestStatus);

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

   853 	ASSERT_EQUALS(RPacketContext::EStatusActive, contextActiveStatus);

   854 

   855 	// Prepare context configuration for GPRS

   856 	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);

   857 	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv6;

   858 	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);

   859 	TPckg<RPacketContext::TContextConfigGPRS> pckgConfigGPRS2(setConfigGPRS);

   860 

   861 	packetContext.SetConfig(setConfigStatus, pckgConfigGPRS2);

   862 	User::WaitForRequest(setConfigStatus);

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

   864 

   865 	/* Request modification, modification should be successful */

   866 	TRequestStatus modifyActiveContextStatus;

   867 	packetContext.ModifyActiveContext(modifyActiveContextStatus);

   868 	User::WaitForRequest(modifyActiveContextStatus);

   869 	ASSERT_EQUALS(KErrNotSupported, modifyActiveContextStatus.Int());

   870 

   871 	TRequestStatus deactivateContextStatus;

   872 	packetContext.Deactivate(deactivateContextStatus);

   873 	User::WaitForRequest(deactivateContextStatus);

   874 	ASSERT_EQUALS(KErrNone, deactivateContextStatus.Int())

   875 

   876 	packetQoS.Close();

   877 	packetContext.Close();

   878 	packetService.Close();

   879 	AssertMockLtsyStatusL();

   880 	config.Reset();

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

   882 	}

   883 

   884 /**

   885 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0007

   886 @SYMComponent telephony_ctsy

   887 @SYMTestCaseDesc Test returned value if EPacketContextInitialiseContext is not supported by LTSY

   888 @SYMTestPriority High

   889 @SYMTestActions Invokes RPacketContext::InitialiseContext()

   890 @SYMTestExpectedResults Pass

   891 @SYMTestType UT

   892 */

   893 void CCTsyPacketServicesFUNegative::TestUnit0007L()

   894 	{

   895 	TConfig config;

   896 	config.SetSupportedValue(MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId, EFalse);

   897 	

   898 	OpenEtelServerL(EUseExtendedError);

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

   900 	OpenPhoneL();

   901 	

   902 	RPacketService packetService;

   903 	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

   904 

   905 	TInfoName contextName;

   906 	contextName.Copy(KFirstAllocatedContextName);

   907 	

   908 	DriverDeleteContextL(contextName);

   909 	

   910 	//Open a New Packet Context

   911 	RPacketContext packetContext;

   912 	CleanupClosePushL(packetContext);

   913 

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

   915 	ASSERT_EQUALS(KErrNone, err);

   916 

   917 	TRequestStatus requestStatus;

   918 	RPacketContext::TDataChannelV2 dataChannel;

   919 	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);

   920 

   921 	packetContext.InitialiseContext(requestStatus,dataChannelPk);

   922 	User::WaitForRequest(requestStatus);

   923     ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);

   924 

   925 	packetContext.Close();

   926 	AssertMockLtsyStatusL();

   927 	config.Reset();	

   928 	CleanupStack::PopAndDestroy(3, this); // packetService, packetContext, this

   929 	}

   930 

   931 /**

   932 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0008

   933 @SYMComponent telephony_ctsy

   934 @SYMTestCaseDesc Test returned value if EPacketContextDelete is not supported by LTSY

   935 @SYMTestPriority High

   936 @SYMTestActions Invokes RPacketContext::Delete()

   937 @SYMTestExpectedResults Pass

   938 @SYMTestType UT

   939 */

   940 void CCTsyPacketServicesFUNegative::TestUnit0008L()

   941 	{

   942 	TConfig config;

   943 	config.SetSupportedValue(MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, EFalse);

   944 	

   945 	OpenEtelServerL(EUseExtendedError);

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

   947 	OpenPhoneL();

   948 		

   949 

   950 	RPacketService packetService;

   951 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

   952 

   953 	// Prepare context configuration fo GPRS

   954 	RPacketContext::TContextConfigGPRS setConfigGPRS;

   955 	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);

   956 	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;

   957 	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);

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

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

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

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

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

   963 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

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

   965 

   966 	// Create the PCO buffer

   967 	RPacketContext::TMiscProtocolBuffer gprsMiscBuffer;

   968 	gprsMiscBuffer.Zero();

   969 

   970 	// Generate a PCO buffer

   971 	PCOGeneratorL(setConfigGPRS.iProtocolConfigOption, gprsMiscBuffer);

   972 	setConfigGPRS.iProtocolConfigOption.iId = KRequestID;

   973 

   974 	//

   975 

   976 	DriverInitialiseContextL();

   977 

   978 	// GPRS Configuration

   979 	TInfoName contextName;

   980 	contextName.Copy(KFirstAllocatedContextName);

   981 

   982 	//

   983 

   984 	// client side test

   985 	RPacketContext packetContext;

   986 

   987 	// Open a new context

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

   989 	CleanupClosePushL(packetContext);

   990 	ASSERT_EQUALS(KErrNone, err);

   991 

   992 	RPacketContext::TDataChannelV2 dataChannel;

   993 	RPacketContext::TDataChannelV2Pckg dataChannelPk(dataChannel);

   994 	TRequestStatus initialiseContextStatus;

   995 

   996 	packetContext.InitialiseContext(initialiseContextStatus,dataChannelPk);

   997 	User::WaitForRequest(initialiseContextStatus);

   998 

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

  1000 	ASSERT_TRUE(dataChannel.iChannelId == KDefaultChannelId);

  1001 

  1002 	TRequestStatus setConfigStatus;

  1003 

  1004 	packetContext.Delete(setConfigStatus);

  1005 	User::WaitForRequest(setConfigStatus);

  1006 	ASSERT_EQUALS(KErrNotSupported, setConfigStatus.Int());

  1007 

  1008 	// Close is not called since it invokes EPacketContextDelete

  1009 	//	packetContext.Close();

  1010 	//	packetService.Close();

  1011 	AssertMockLtsyStatusL();

  1012 	config.Reset();

  1013 	CleanupStack::PopAndDestroy(3, this); // packetService, packetContext, this

  1014 	}

  1015 

  1016 /**

  1017 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0009

  1018 @SYMComponent telephony_ctsy

  1019 @SYMTestCaseDesc Test returned value if EPacketSetAttachMode is not supported by LTSY

  1020 @SYMTestPriority High

  1021 @SYMTestActions Invokes RPacketService::SetAttachMode()

  1022 @SYMTestExpectedResults Pass

  1023 @SYMTestType UT

  1024 */

  1025 void CCTsyPacketServicesFUNegative::TestUnit0009L()

  1026 	{

  1027 	TConfig config;

  1028 	config.SetSupportedValue(MLtsyDispatchPacketServicesSetPacketAttachMode::KLtsyDispatchPacketServicesSetPacketAttachModeApiId, EFalse);

  1029 	

  1030 	OpenEtelServerL(EUseExtendedError);

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

  1032 	OpenPhoneL();

  1033 	

  1034 	RPacketService packetService;

  1035 	OpenPacketServiceLC(packetService, RPacketService::EStatusUnattached);

  1036 	

  1037 	TRequestStatus requestStatus;

  1038 	RPacketService::TAttachMode attachMode = RPacketService::EAttachWhenPossible;

  1039     

  1040 	packetService.SetAttachMode(requestStatus, attachMode);	

  1041 	User::WaitForRequest(requestStatus);

  1042 	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

  1043 

  1044     AssertMockLtsyStatusL();

  1045 	config.Reset();

  1046 	CleanupStack::PopAndDestroy(2, this); // packetService, this

  1047 	}

  1048 

  1049 /**

  1050 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0010

  1051 @SYMComponent telephony_ctsy

  1052 @SYMTestCaseDesc Test returned value if EPacketNotifyStatusChange - *Notify* NOT NEEDED

  1053 @SYMTestPriority High

  1054 @SYMTestActions Invokes 

  1055 @SYMTestExpectedResults Pass

  1056 @SYMTestType UT

  1057 */

  1058 void CCTsyPacketServicesFUNegative::TestUnit0010L()

  1059 	{

  1060 	TConfig config;

  1061 	config.SetSupportedValue(MLtsyDispatchPacketServicesNotifyPacketStatusChange::KLtsyDispatchPacketServicesNotifyPacketStatusChangeApiId, EFalse);

  1062 	

  1063 	OpenEtelServerL(EUseExtendedError);

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

  1065 	OpenPhoneL();

  1066 

  1067 	AssertMockLtsyStatusL();

  1068 	config.Reset();

  1069 	CleanupStack::PopAndDestroy(this); // , this

  1070 	}

  1071 

  1072 /**

  1073 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0011

  1074 @SYMComponent telephony_ctsy

  1075 @SYMTestCaseDesc Test returned value if EPacketSetDefaultContextParams is not supported by LTSY

  1076 @SYMTestPriority High

  1077 @SYMTestActions Invokes RPacketService::SetDefaultContextParams()

  1078 @SYMTestExpectedResults Pass

  1079 @SYMTestType UT

  1080 */

  1081 void CCTsyPacketServicesFUNegative::TestUnit0011L()

  1082 	{

  1083 	TConfig config;

  1084 	config.SetSupportedValue(MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams::KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId, EFalse);

  1085 	// or MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params::KLtsyDispatchPacketServicesSetDefaultPdpContextR99R4ParamsApiId

  1086 	

  1087 	OpenEtelServerL(EUseExtendedError);

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

  1089 	OpenPhoneL();

  1090 

  1091 	RPacketService packetService;

  1092 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

  1093 

  1094 	RPacketContext::TContextConfigGPRS defaultGprsContextConfig;

  1095 	defaultGprsContextConfig.iAccessPointName = KDefaultAccessPoint;

  1096 	defaultGprsContextConfig.iPdpType = KDefaultPdpType;

  1097 	TPckg<RPacketContext::TContextConfigGPRS> defaultContextGprsConfigPckg(defaultGprsContextConfig);

  1098 	

  1099 	TRequestStatus requestStatus;

  1100 	packetService.SetDefaultContextParams(requestStatus, defaultContextGprsConfigPckg);

  1101 	User::WaitForRequest(requestStatus);

  1102     ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);

  1103 

  1104 	AssertMockLtsyStatusL();

  1105 	config.Reset();

  1106 	CleanupStack::PopAndDestroy(2, this); // packetService, this

  1107 	}

  1108 

  1109 /**

  1110 @SYMTestCaseID BA-CTSYD-DIS-PACKETSERVICES-NEGATIVE-UN0012

  1111 @SYMComponent telephony_ctsy

  1112 @SYMTestCaseDesc Test returned value if EPacketContextActivate is not supported by LTSY

  1113 @SYMTestPriority High

  1114 @SYMTestActions Invokes RPacketContext::Activate()

  1115 @SYMTestExpectedResults Pass

  1116 @SYMTestType UT

  1117 */

  1118 void CCTsyPacketServicesFUNegative::TestUnit0012L()

  1119 	{

  1120 	TConfig config;

  1121 	config.SetSupportedValue(MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, EFalse);

  1122 	

  1123 	OpenEtelServerL(EUseExtendedError);

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

  1125 	OpenPhoneL();

  1126 	

  1127 	RPacketService packetService;

  1128 	OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached);

  1129 

  1130 	// Prepare context configuration fo GPRS

  1131 	RPacketContext::TContextConfigGPRS setConfigGPRS;

  1132 	setConfigGPRS.iAccessPointName.Copy(KPointNameGPRS);

  1133 	setConfigGPRS.iPdpType = RPacketContext::EPdpTypeIPv4;

  1134 	setConfigGPRS.iPdpAddress.Copy(KPdpAddGPRS);

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