1 // Copyright (c) 2007-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 // Test step definitions for the PacketService functional unit.

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include <etelpckt.h>

    23 #include <pcktcs.h>

    24 

    25 #include "cctsyintegrationtestpacketservice.h"

    26 

    27 #include "cetelsessionmgr.h"

    28 #include "tetelrequeststatus.h"

    29 #include "tsmsstoretsytesthelper.h"

    30 

    31 _LIT(KPrompt, "This test requires network simulation,Press a key if simualted network is ready");

    32 CCTSYIntegrationTestPacketServiceBase::CCTSYIntegrationTestPacketServiceBase(CEtelSessionMgr& aEtelSessionMgr)

    33 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iPacketServiceTestHelper(*this), iNetworkTestHelper(*this)

    34 /**

    35  * Constructor

    36  */

    37 	{

    38 	}

    39 

    40 CCTSYIntegrationTestPacketServiceBase::~CCTSYIntegrationTestPacketServiceBase()

    41 /*

    42  * Destructor

    43  */

    44 	{

    45 	}

    46 	

    47 /**

    48  * Ensures that the correct attach mode is set and leaves if not

    49  @param aPacketService RPacketService service

    50  @param aModeAttach give information about the desired mode. The function leaves if the required mode is not there.

    51  */

    52  void CCTSYIntegrationTestPacketServiceBase::EnsureAttachModeL( RPacketService &aPacketService, RPacketService::TAttachMode &aModeAttach)

    53  	{

    54 

    55  	// Get attach mode to check whether it is already RPacketService::EAttachWhenNeeded		

    56 	TExtEtelRequestStatus getAttachModeStatus (aPacketService,EPacketGetAttachMode);

    57 	CleanupStack::PushL(getAttachModeStatus);	

    58 	RPacketService::TAttachMode attachMode;

    59 	aPacketService.GetAttachMode(getAttachModeStatus, attachMode);

    60 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeMedium), KErrNone, 

    61 					_L("PacketService::GetAttachMode timed out"));

    62 	CHECK_EQUALS_L(getAttachModeStatus.Int(), KErrNone, 

    63 					_L("PacketService::GetAttachMode returned an error"));

    64 

    65 	// If the attach mode is not RPacketService::EAttachWhenNeeded, then set it

    66 	TExtEtelRequestStatus setAttachModeStatus(aPacketService, EPacketSetAttachMode);

    67 	CleanupStack::PushL(setAttachModeStatus);	

    68 	if (attachMode != aModeAttach)	

    69 		{

    70 		// Set attach mode to RPacketService::EAttachWhenNeeded with RPacketService::SetAttachMode

    71 		aPacketService.SetAttachMode(setAttachModeStatus, aModeAttach);

    72 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setAttachModeStatus, ETimeLong), KErrNone,	

    73 						_L("PacketService::SetAttachMode timed out."));								

    74 		CHECK_EQUALS_L(setAttachModeStatus.Int(), KErrNone, 

    75 						_L("PacketService::SetAttachMode returned an error"));		

    76 		

    77 		// Check that it was set

    78 		aPacketService.GetAttachMode(getAttachModeStatus,attachMode);

    79 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeMedium), KErrNone,

    80 						_L("PacketService::GetAttachMode timed out"));

    81 		CHECK_EQUALS_L(getAttachModeStatus.Int(), KErrNone, 

    82 						_L("PacketService::GetAttachMode returned an error"));			

    83 		}		

    84 	

    85 	CHECK_EQUALS_L(attachMode, aModeAttach, _L("PacketService::GetAttachMode did not return the desired attach mode"));

    86 	

    87 	// getAttachModeStatus

    88 	// setAttachModeStatus

    89 	CleanupStack::PopAndDestroy(2, &getAttachModeStatus);

    90  	}

    91  //*************************************************************************	

    92 

    93 

    94 

    95 CCTSYIntegrationTestPacketService0001::CCTSYIntegrationTestPacketService0001(CEtelSessionMgr& aEtelSessionMgr)

    96 	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

    97 /**

    98  * Constructor.

    99  */

   100 	{

   101 	SetTestStepName(CCTSYIntegrationTestPacketService0001::GetTestStepName());

   102 	}

   103 

   104 CCTSYIntegrationTestPacketService0001::~CCTSYIntegrationTestPacketService0001()

   105 /**

   106  * Destructor.

   107  */

   108 	{

   109 	}

   110 

   111 TVerdict CCTSYIntegrationTestPacketService0001::doTestStepL()

   112 /**

   113  * @SYMTestCaseID BA-CTSY-INT-PKTS-0001

   114  * @SYMFssID BA/CTSY/PKTS-0001

   115  * @SYMTestCaseDesc Get static caps.

   116  * @SYMTestPriority High

   117  * @SYMTestActions 

   118  * @SYMTestExpectedResults Pass - Static caps returned.

   119  * @SYMTestType CIT

   120  * @SYMTestCaseDependencies live/automatic

   121  *

   122  * Reason for test: Get static caps for each protocol type.

   123  *

   124  * @return - TVerdict code

   125  */

   126 	{

   127 

   128 	//

   129 	// SET UP

   130 	//

   131 

   132 	

   133 

   134 	//

   135 	// SET UP END

   136 	//

   137 	

   138 	StartTest();

   139 	

   140 	//

   141 	// TEST START

   142 	//

   143 	

   144 	

   145 	// Get packet service 

   146 	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer, 

   147 																	  KMainPhone,

   148 																	  KMainPacketService);

   149 	

   150 	// Check static caps are 

   151 	// RPacketService::KCapsSuspendSupported |

   152 	// RPacketService::KCapsNetworkAvailabilitySupported | 

   153 	// RPacketService::KCapsSetDefaultContextSupported | RPacketService::KCapsChangeAttachModeSupported | 

   154 	// RPacketService::KCapsGetDataTransferredSupported | RPacketService::KCapsPreferredBearerSupported | 

   155 	// RPacketService::KCapsPdpDataCompSupported | RPacketService::KCapsPdpHeaderCompSupported | 

   156 	// RPacketService::KCapsNotifyMSClassSupported

   157 	TUint staticCaps = 0;

   158 	TUint expectedCaps = 	RPacketService::KCapsSuspendSupported |

   159 							RPacketService::KCapsNetworkAvailabilitySupported | 

   160 							RPacketService::KCapsSetDefaultContextSupported | 

   161 							RPacketService::KCapsChangeAttachModeSupported | 

   162 							RPacketService::KCapsGetDataTransferredSupported | 

   163 							RPacketService::KCapsPreferredBearerSupported | 

   164 							RPacketService::KCapsPdpDataCompSupported | 

   165 							RPacketService::KCapsPdpHeaderCompSupported | 

   166 							RPacketService::KCapsNotifyMSClassSupported;

   167 	ASSERT_EQUALS(packetService.GetStaticCaps(staticCaps, RPacketContext::EPdpTypeIPv4), KErrNone, _L("RPacketService::GetStaticCaps returned an error"));

   168 	ASSERT_BITS_SET(staticCaps, expectedCaps, KNoUnwantedBits,

   169 			_L("RPacketService::GetStaticCaps did not return correct static caps"));

   170 	

   171 	//

   172 	// TEST END

   173 	//

   174 

   175     StartCleanup();

   176 	

   177 	return TestStepResult();

   178 	}

   179 

   180 TPtrC CCTSYIntegrationTestPacketService0001::GetTestStepName()

   181 /**

   182  * @return The test step name.

   183  */

   184 	{

   185 	return _L("CCTSYIntegrationTestPacketService0001");

   186 	}

   187 

   188 

   189 

   190 CCTSYIntegrationTestPacketService0002::CCTSYIntegrationTestPacketService0002(CEtelSessionMgr& aEtelSessionMgr)

   191 	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

   192 /**

   193  * Constructor.

   194  */

   195 	{

   196 	SetTestStepName(CCTSYIntegrationTestPacketService0002::GetTestStepName());

   197 	}

   198 

   199 CCTSYIntegrationTestPacketService0002::~CCTSYIntegrationTestPacketService0002()

   200 /**

   201  * Destructor.

   202  */

   203 	{

   204 	}

   205 

   206 TVerdict CCTSYIntegrationTestPacketService0002::doTestStepL()

   207 /**

   208  * @SYMTestCaseID BA-CTSY-INT-PKTS-0002

   209  * @SYMFssID BA/CTSY/PKTS-0002

   210  * @SYMTestCaseDesc Automatic attach to the packet service when attach mode changed to EAttachWhenPossible.

   211  * @SYMTestPriority High

   212  * @SYMTestActions RPacketService::NotifyAttachModeChange, RPacketService::GetNtwkRegStatus, RPacketService::GetStatus, RPacketService::GetAttachMode, RPacketService::NotifyDynamicCapsChange, RPacketService::GetDynamicCaps, RPacketService::NotifyStatusChange, RPacketService::GetStaticCaps

   213  * @SYMTestExpectedResults Pass - Phone automatically attached to packet service.

   214  * @SYMTestType CIT

   215  * @SYMTestCaseDependencies live/automatic

   216  *

   217  * Reason for test: Verify that packet service attaches automatically when attach mode is changed to EAttachWhenPossible.

   218  * Verify static caps, packet network registration status,  dynamic caps are correct. 

   219  *

   220  * @return - TVerdict code

   221  */

   222 	{

   223 

   224 	//

   225 	// SET UP

   226 	//

   227 

   228 	// Get packet service

   229 	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer,

   230 																	  KMainPhone,

   231 																	  KMainPacketService);

   232 	// Get mobile phone

   233 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   234 	

   235 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   236 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone,

   237 					_L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   238 		

   239 	// Ensure attach mode is RPacketService::EAttachWhenNeeded

   240 	RPacketService::TAttachMode attachMode= RPacketService::EAttachWhenNeeded; 

   241 	EnsureAttachModeL(packetService,attachMode);

   242 	User::After(10*KOneSecond); // This time delay is required to complete the implicit detach operation caused by EAttachWhenNeeded attach mode

   243 	

   244 	// Ensure packet service status is EStatusUnattached

   245 	RPacketService::TStatus setUpStatus;

   246 	CHECK_EQUALS_L(packetService.GetStatus(setUpStatus), KErrNone, 

   247 					_L("PacketService::GetStatus returned an error"));

   248 	TExtEtelRequestStatus detachStatus(packetService, EPacketDetach);

   249 	CleanupStack::PushL(detachStatus);

   250 	if (setUpStatus != RPacketService::EStatusUnattached)

   251 		{

   252 		packetService.Detach(detachStatus);

   253 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(detachStatus, ETimeMedium), KErrNone, 	

   254 						_L("PacketService::Detach timed out"));

   255 		CHECK_TRUE_L(detachStatus.Int()== KErrNone|| detachStatus.Int()== KErrAlreadyExists, 

   256 						_L("PacketService::Detach returned an error"));										

   257 		}

   258 	User::After(5*KOneSecond); // Time delay is needed to detach properly

   259 	//

   260 	// SET UP END

   261 	//

   262 	

   263 	StartTest();

   264 	

   265 	//

   266 	// TEST START

   267 	//

   268 	

   269 	// Check RPacketService::GetStatus returns RPacketService::EStatusUnattached

   270 	RPacketService::TStatus serviceStatus; 

   271 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone,

   272 					_L("PacketService::GetStatus returned with an error."));

   273 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusUnattached, 

   274 					_L("RPacketService::GetStatus did not return RPacketService::EStatusUnattached."));

   275 		

   276 	// Check RPacketService::GetDynamicCaps returns caps in set of 

   277 	// RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall

   278 	// Check RPacketService::GetDynamicCaps returns caps NOT in set of 

   279 	// RPacketService::KCapsSMSTransfer | RPacketService::KCapsManualDetach | 

   280 	// RPacketService::KCapsRxContextActivationReq

   281 	RPacketService::TDynamicCapsFlags dynCaps;

   282 	ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

   283 					_L("RPacketService::GetDynamicCaps returned with an error"));

   284 	RPacketService::TDynamicCapsFlags expectedCaps = 

   285 					RPacketService::KCapsManualAttach | 

   286 					RPacketService::KCapsRxCSCall;

   287 	RPacketService::TDynamicCapsFlags unwantedCaps = 

   288 					RPacketService::KCapsSMSTransfer | 

   289 					RPacketService::KCapsManualDetach | 

   290 					RPacketService::KCapsRxContextActivationReq;

   291 	ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps,

   292 		_L("RPacketService::GetDynamicCaps did not return correct dynamic caps")); // NOTE: Use ASSERT_BITS_SET for wanted and unwanted bits, name the variables expectedCaps and unwantedCaps or similar

   293 

   294 	// Post notification for RPacketService::NotifyAttachModeChange   

   295 	TExtEtelRequestStatus notifyAttachModeChangeStatus(packetService, EPacketNotifyAttachModeChange); // NOTE: Name the request status object so that it is possible to identify which API it is for since they cannot be used for a different API

   296 	CleanupStack::PushL(notifyAttachModeChangeStatus); // NOTE: Always push EVERY TExtEtelRequestStatus and TCoreEtelRequestStatus onto the CleanupStack

   297 	packetService.NotifyAttachModeChange(notifyAttachModeChangeStatus, attachMode);

   298 	

   299 	// Post notification for RPacketService::NotifyStatusChange

   300 	TExtEtelRequestStatus notifyStatusStatus(packetService, EPacketNotifyStatusChange);

   301 	CleanupStack::PushL(notifyStatusStatus); 

   302 	RPacketService::TStatus packetServiceStatus;

   303 	packetService.NotifyStatusChange(notifyStatusStatus, packetServiceStatus);

   304 	

   305 	// Post notification for RPacketService::NotifyDynamicCapsChange

   306 	TExtEtelRequestStatus notifyDynamicCapsChangeStatus(packetService, EPacketNotifyDynamicCapsChange);

   307 	CleanupStack::PushL(notifyDynamicCapsChangeStatus);

   308 	packetService.NotifyDynamicCapsChange(notifyDynamicCapsChangeStatus, dynCaps);

   309 		

   310 	// Set attach mode to RPacketService::EAttachWhenPossible with RPacketService::SetAttachMode

   311 	TExtEtelRequestStatus setAttachModeStatus(packetService, EPacketSetAttachMode);

   312 	CleanupStack::PushL(setAttachModeStatus); 

   313 	packetService.SetAttachMode(setAttachModeStatus, RPacketService::EAttachWhenPossible);

   314 	ASSERT_EQUALS(WaitForRequestWithTimeOut(setAttachModeStatus, ETimeLong), KErrNone, 

   315 					_L("RPacketService::SetAttachMode timed-out")); 

   316 	ASSERT_EQUALS(setAttachModeStatus.Int(), KErrNone, 

   317 					_L("RPacketService::SetAttachMode returned with an error"));

   318 	User::After(10*KOneSecond); // This time delay is required to complete the implicit attach operation caused by EAttachWhenPossible attach mode

   319 	

   320 	// Check RPacketService::NotifyAttachModeChange completes with RPacketService::EAttachWhenPossible  

   321 	RPacketService::TAttachMode expectedAttachMode = RPacketService::EAttachWhenPossible;

   322 	iPacketServiceTestHelper.WaitForPacketServiceNotifyAttachModeChange(packetService, 

   323 																		notifyAttachModeChangeStatus, 

   324 																		attachMode, 

   325 																		expectedAttachMode, 

   326 																		KErrNone);

   327 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10049);

   328 	

   329 	// Check RPacketService::GetAttachMode returns RPacketService::EAttachWhenPossible

   330 	TExtEtelRequestStatus getAttachModeStatus(packetService, EPacketGetAttachMode);

   331 	CleanupStack::PushL(getAttachModeStatus);

   332 	packetService.GetAttachMode(getAttachModeStatus, attachMode);

   333 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeShort), KErrNone,

   334 					_L("RPacketService::GetAttachMode timed-out"));

   335 	ASSERT_EQUALS(getAttachModeStatus.Int(), KErrNone, 

   336 					_L("RPacketService::GetAttachMode returned with an error"));

   337 	ASSERT_EQUALS(attachMode, RPacketService::EAttachWhenPossible, 

   338 					_L("RPacketService::GetAttachMode did not return RPacketService::EAttachWhenPossible"));

   339 	

   340 	// Check RPacketService::NotifyStatusChange completes with RPacketService::EStatusAttached

   341 	RPacketService::TStatus expectedPacketServiceStatus = RPacketService::EStatusAttached;

   342 	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService, 

   343 																	notifyStatusStatus,

   344 																	packetServiceStatus,

   345 																	expectedPacketServiceStatus,

   346 																	KErrNone);

   347 

   348 	// Check RPacketService::NotifyDynamicCapsChange completes with caps in set of KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer

   349 	// Check RPacketService::NotifyDynamicCapsChange completes with caps NOT in set of RPacketService::KCapsManualAttach

   350 	expectedCaps = 	RPacketService::KCapsRxCSCall | 

   351 					RPacketService::KCapsRxContextActivationReq | 

   352 					RPacketService::KCapsManualDetach | 

   353 					RPacketService::KCapsSMSTransfer;

   354 	unwantedCaps =  RPacketService::KCapsManualAttach;

   355 	iPacketServiceTestHelper.WaitForPacketServiceNotifyDynamicCapsChange(packetService,

   356 																		 notifyDynamicCapsChangeStatus,

   357 																		 dynCaps, 

   358 																		 expectedCaps,

   359 																		 unwantedCaps,

   360 																		 KErrNone);

   361 

   362 	// Check RPacketService::GetStatus returns RPacketService::EStatusAttached

   363 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone, 

   364 					_L("RPacketService::GetStatus returned with an error"));

   365 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusAttached, 

   366 					_L("RPacketService::GetStatus did not return RPacketService::EStatusAttached"));

   367 

   368 	// Check RPacketService::GetDynamicCaps returns caps in set of KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer.

   369 	// Check RPacketService::GetDynamicCaps completes with caps NOT in set of RPacketService::KCapsManualAttach

   370     ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone,

   371     				_L("RPacketService::GetDynamicCaps returned with an error"));

   372     expectedCaps = 	RPacketService::KCapsRxCSCall | 

   373     				RPacketService::KCapsRxContextActivationReq | 

   374     				RPacketService::KCapsManualDetach | 

   375     				RPacketService::KCapsSMSTransfer;

   376     unwantedCaps = 	RPacketService::KCapsManualAttach;

   377     ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, 

   378     		_L("RPacketService::GetDynamicCaps did not return correct dynamic caps"));

   379 

   380 	// Check RPacketService::GetNtwkRegStatus returns ERegisteredOnHomeNetwork

   381     TExtEtelRequestStatus regStatus(packetService, EPacketGetNtwkRegStatus);

   382     CleanupStack::PushL(regStatus);

   383     RPacketService::TRegistrationStatus registrationStatus;

   384     packetService.GetNtwkRegStatus(regStatus, registrationStatus);

   385 	ASSERT_EQUALS(WaitForRequestWithTimeOut(regStatus, ETimeMedium), KErrNone,

   386 					_L("RPacketService::GetNtwkRegStatus timed-out."));

   387 	ASSERT_EQUALS(regStatus.Int(), KErrNone, 

   388 					_L("RPacketService::GetNtwkRegStatus returned with an error"));

   389     ASSERT_EQUALS(registrationStatus, RPacketService::ERegisteredOnHomeNetwork, 

   390     				_L("RPacketService::GetNtwkRegStatus did not return RPacketService::ERegisteredOnHomeNetwork"));

   391 

   392     //

   393     // Test end

   394     //

   395     		

   396     StartCleanup();

   397 	

   398     // Pop:

   399 	// detachStatus

   400 	// notifyAttachModeChangeStatus

   401     // notifyStatusStatus

   402 	// notifyDynamicCapsChangeStatus

   403 	// setAttachModeStatus

   404 	// getAttachModeStatus

   405 	// regStatus

   406 	CleanupStack::PopAndDestroy(7, &detachStatus); 

   407 	

   408 	return TestStepResult();

   409 	}

   410 

   411 TPtrC CCTSYIntegrationTestPacketService0002::GetTestStepName()

   412 /**

   413  * @return The test step name.

   414  */

   415 	{

   416 	return _L("CCTSYIntegrationTestPacketService0002");

   417 	}

   418 

   419 

   420 

   421 CCTSYIntegrationTestPacketService0003::CCTSYIntegrationTestPacketService0003(CEtelSessionMgr& aEtelSessionMgr)

   422 	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

   423 /**

   424  * Constructor.

   425  */

   426 	{

   427 	SetTestStepName(CCTSYIntegrationTestPacketService0003::GetTestStepName());

   428 	}

   429 

   430 CCTSYIntegrationTestPacketService0003::~CCTSYIntegrationTestPacketService0003()

   431 /**

   432  * Destructor.

   433  */

   434 	{

   435 	}

   436 

   437 TVerdict CCTSYIntegrationTestPacketService0003::doTestStepL()

   438 /**

   439  * @SYMTestCaseID BA-CTSY-INT-PKTS-0003

   440  * @SYMFssID BA/CTSY/PKTS-0003

   441  * @SYMTestCaseDesc Automatic attach to the packet service, when Context Activated and attach mode is EAttachWhenNeeded.

   442  * @SYMTestPriority High

   443  * @SYMTestActions RPacketService::GetNtwkRegStatus, RPacketService::GetStatus, RPacketService::GetAttachMode, RPacketService::NotifyDynamicCapsChange, RPacketService::GetDynamicCaps, RPacketService::NotifyStatusChange, RPacketService::NotifyContextAdded, RPacketService::EnumerateContexts, RPacketContext::NotifyStatusChange, RPacketContext::GetStatus

   444  * @SYMTestExpectedResults Pass - Packet service is active.

   445  * @SYMTestType CIT

   446  * @SYMTestCaseDependencies live/automatic

   447  *

   448  * Reason for test: Verify that automatic attach occurs when a packet context is activated.

   449 

   450 Verify packet network registration status,  dynamic caps, number of active contexts, context status are correct.

   451  *

   452  * @return - TVerdict code

   453  */

   454 	{

   455 	

   456 	

   457 	// Attach to the packet service with attach mode set to EAttachWhenNeeded by Activating a context

   458 	//

   459 	// SET UP

   460 	//

   461 	

   462 	// Start with attach mode in RPacketService::EAttachWhenNeeded.

   463 	// Get packet service

   464 	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer,

   465 																	  KMainPhone,

   466 																	  KMainPacketService);

   467 	

   468 	// Get mobile phone

   469 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   470 	

   471 	// Get packet context

   472 	RPacketContext& packetContext = iEtelSessionMgr.GetPrimaryPacketContextL(KMainServer,

   473 																			 KMainPhone,

   474 																			 KMainPacketService,

   475 																			 KPrimaryPacketContext1); 

   476 	

   477 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   478 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone,

   479 					_L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   480 	

   481 	// Ensure attach mode is RPacketService::EAttachWhenNeeded

   482 	RPacketService::TAttachMode attachMode= RPacketService::EAttachWhenNeeded; 

   483 	EnsureAttachModeL(packetService,attachMode);

   484 	User::After(10*KOneSecond); // This time delay is required to complete the implicit detach operation caused by EAttachWhenNeeded attach mode

   485 	

   486 	// Ensure packet service status is EStatusUnattached

   487 	RPacketService::TStatus setUpStatus;

   488 	CHECK_EQUALS_L(packetService.GetStatus(setUpStatus), KErrNone, 

   489 					_L("PacketService::GetStatus returned an error"));

   490 	TExtEtelRequestStatus detachStatus(packetService, EPacketDetach);

   491 	CleanupStack::PushL(detachStatus);

   492 	if (setUpStatus != RPacketService::EStatusUnattached)

   493 		{

   494 		packetService.Detach(detachStatus);

   495 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(detachStatus, ETimeMedium), KErrNone, 	

   496 						_L("PacketService::Detach timed out"));

   497 		CHECK_TRUE_L(detachStatus.Int()== KErrNone|| detachStatus.Int()== KErrAlreadyExists, 

   498 						_L("PacketService::Detach returned an error"));										

   499 		}

   500 	

   501 	//

   502 	// SET UP END

   503 	//

   504 	

   505 	StartTest();

   506 	

   507 	//

   508 	// TEST START

   509 	//

   510 

   511 	// Check RPacketService::GetStatus returns RPacketService::EStatusUnattached

   512 	RPacketService::TStatus serviceStatus;

   513 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone, 

   514 					_L("PacketService::GetStatus returned with an error."));

   515 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusUnattached, 

   516 					_L("PacketService::GetStatus did not return RPacketService::EStatusUnattached."));

   517 				

   518 	// Check RPacketService::GetDynamicCaps returns caps in set of RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall

   519 	// Check RPacketService::GetDynamicCaps returns caps NOT in set of RPacketService::KCapsSMSTransfer | RPacketService::KCapsManualDetach | RPacketService::KCapsRxContextActivationReq

   520     RPacketService::TDynamicCapsFlags dynCaps = 0;		

   521 	ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

   522 					_L("PacketService::GetDynamicCaps returned an error"));

   523 	//$CTSYProblem - Caps returned is KCapsActive, caps not in set of RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall 

   524 	RPacketService::TDynamicCapsFlags expectedCaps = RPacketService::KCapsActivate;

   525 	RPacketService::TDynamicCapsFlags unwantedCaps = RPacketService::KCapsSMSTransfer | 

   526 													 RPacketService::KCapsManualDetach | 

   527 													 RPacketService::KCapsRxContextActivationReq;

   528 	ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps,          

   529 					_L("PacketService::GetDynamicCaps Wrong dynamic caps"));

   530 

   531 	// Post notification for packet service status change

   532 	TExtEtelRequestStatus notifyStatusStatus(packetService, EPacketNotifyStatusChange);

   533 	CleanupStack::PushL(notifyStatusStatus); 

   534 	RPacketService::TStatus packetServiceStatus;

   535 	packetService.NotifyStatusChange(notifyStatusStatus, packetServiceStatus);

   536 	

   537 	// Post notification for dynamic caps change

   538 	TExtEtelRequestStatus notifyDynamicCapsChangeStatus(packetService, EPacketNotifyDynamicCapsChange);

   539 	CleanupStack::PushL(notifyDynamicCapsChangeStatus);

   540 	packetService.NotifyDynamicCapsChange(notifyDynamicCapsChangeStatus, dynCaps);

   541 		

   542 	// Activate a new context

   543 	iPacketServiceTestHelper.ActivatePrimaryPacketContextL(mobilePhone, packetContext );

   544 		

   545 	// Check RPacketService::NotifyStatusChange completes with EStatusAttached->EStausActive

   546 	RPacketService::TStatus expectedPacketServiceStatus = RPacketService::EStatusAttached;

   547 	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService, 

   548 																	notifyStatusStatus, 

   549 																	packetServiceStatus,

   550 																	expectedPacketServiceStatus,

   551 																	KErrNone);

   552 	// Post notification for packet service status change

   553 	packetService.NotifyStatusChange(notifyStatusStatus, packetServiceStatus);

   554 	

   555 	// Check RPacketService::NotifyStatusChange completes with EStausActive

   556 	expectedPacketServiceStatus = RPacketService::EStatusActive;

   557 	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService, 

   558 																	notifyStatusStatus, 

   559 																	packetServiceStatus,

   560 																	expectedPacketServiceStatus,

   561 																	KErrNone);

   562 

   563 	//  Check RPacketService::NotifyDynamicCapsChange completes with caps in set of  KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer

   564 	//	Check RPacketService::NotifyDynamicCapsChange completes with caps NOT in set of RPacketService::KCapsManualAttach

   565 	expectedCaps = RPacketService::KCapsRxCSCall | 

   566 				   RPacketService::KCapsRxContextActivationReq | 

   567 				   RPacketService::KCapsManualDetach | 

   568 				   RPacketService::KCapsSMSTransfer;

   569 	unwantedCaps = RPacketService::KCapsManualAttach;

   570 	iPacketServiceTestHelper.WaitForPacketServiceNotifyDynamicCapsChange(packetService,

   571 																		 notifyDynamicCapsChangeStatus,

   572 																		 dynCaps,

   573 																		 expectedCaps,

   574 																		 unwantedCaps,

   575 																		 KErrNone);

   576 

   577 	// Check RPacketService::GetStatus returns RPacketService::EStatusActive

   578 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone, 

   579 					_L("PacketService::GetStatus returned with an error."));

   580 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusActive, 

   581 					_L("PacketService::GetStatus did not return RPacketService::EStatusActive."));	

   582 	

   583 	// Check RPacketService::GetNtwkRegStatus returns ERegisteredOnHomeNetwork

   584 	TExtEtelRequestStatus regStatus(packetService, EPacketGetNtwkRegStatus);

   585 	CleanupStack::PushL(regStatus);

   586 	RPacketService::TRegistrationStatus registrationStatus;

   587 	packetService.GetNtwkRegStatus(regStatus, registrationStatus);

   588 	ASSERT_EQUALS(WaitForRequestWithTimeOut(regStatus, ETimeMedium),KErrNone, 

   589 					_L("PacketService::GetNtwkRegStatus timed out"));

   590 	ASSERT_EQUALS(regStatus.Int(), KErrNone, 

   591 	    			_L("PacketService::GetNtwkRegStatus returned an error"));

   592 	ASSERT_EQUALS(registrationStatus, RPacketService::ERegisteredOnHomeNetwork, 

   593 	    			_L("PacketService::GetNtwkRegStatus Wrong registration status"));

   594 

   595 	// Check RPacketService::GetDynamicCaps returns caps in set of KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer

   596 	// Check RPacketService::GetDynamicCaps returns caps NOT in set of RPacketService::KCapsManualAttach

   597     ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

   598 					_L("PacketService::GetDynamicCaps returned an error"));

   599     ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, 

   600 					_L("PacketService::GetDynamicCaps Wrong dynamic caps"));

   601     

   602 	// Check RPacketService::EnumerateContexts returns aCount, 1 and aMaxAllowed, 11 (KMmMaxNumberOfContexts in CTSY)	

   603 	TInt count = 0;

   604     TInt maxAllowed = 0;

   605 	TExtEtelRequestStatus enumContextStatus(packetService, EPacketEnumerateContexts);

   606     CleanupStack::PushL(enumContextStatus);

   607 	packetService.EnumerateContexts(enumContextStatus,count,maxAllowed);

   608 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumContextStatus, ETimeMedium),KErrNone, 

   609 					_L("PacketService::EnumerateContexts timed out"));

   610 	ASSERT_EQUALS(enumContextStatus.Int(), KErrNone, 

   611 					_L("PacketService::EnumerateContexts returned an error"));

   612 	ASSERT_EQUALS(count, COUNT_ONE, 

   613 					_L("PacketService::EnumerateContexts, wrong count returned"));

   614 	ASSERT_EQUALS(maxAllowed, MAX_CONTEXTS, 

   615 				_L("PacketService::EnumerateContexts, wrong max count returned"));

   616 

   617 	// deactivate the context and detach from packet service

   618 	TExtEtelRequestStatus deactivateStatus(packetService, EPacketContextDeactivate);

   619 	CleanupStack::PushL(deactivateStatus);

   620 	packetContext.Deactivate(deactivateStatus);			

   621 	ASSERT_EQUALS(WaitForRequestWithTimeOut(deactivateStatus, ETimeMedium),KErrNone, 

   622 					_L("PacketContext::Deactivate timed out"));	

   623 	ASSERT_EQUALS(deactivateStatus.Int(), KErrNone, 

   624 					_L("PacketContext::Deactivate returned an error"));		

   625 	

   626 	//

   627     // Test end

   628     //

   629     		

   630     StartCleanup();

   631 		

   632     // Pop:

   633    	// detachStatus

   634 	// notifyStausStaus

   635 	// notifyDynamicCapsChangeStatus

   636 	// regStatus

   637 	// enumContextStatus

   638 	// deactivateStatus

   639 	CleanupStack::PopAndDestroy(6, &detachStatus); 

   640 	return TestStepResult();

   641 	}

   642 	

   643 TPtrC CCTSYIntegrationTestPacketService0003::GetTestStepName()

   644 /**

   645  * @return The test step name.

   646  */

   647 	{

   648 	return _L("CCTSYIntegrationTestPacketService0003");

   649 	}

   650 

   651 

   652 

   653 CCTSYIntegrationTestPacketService0004::CCTSYIntegrationTestPacketService0004(CEtelSessionMgr& aEtelSessionMgr)

   654 	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

   655 /**

   656  * Constructor.

   657  */

   658 	{

   659 	SetTestStepName(CCTSYIntegrationTestPacketService0004::GetTestStepName());

   660 	}

   661 

   662 CCTSYIntegrationTestPacketService0004::~CCTSYIntegrationTestPacketService0004()

   663 /**

   664  * Destructor.

   665  */

   666 	{

   667 	}

   668 

   669 TVerdict CCTSYIntegrationTestPacketService0004::doTestStepL()

   670 /**

   671  * @SYMTestCaseID BA-CTSY-INT-PKTS-0004

   672  * @SYMFssID BA/CTSY/PKTS-0004

   673  * @SYMTestCaseDesc Automatic attach and detach to the packet service.

   674  * @SYMTestPriority High

   675  * @SYMTestActions RPacketService::NotifyAttachModeChange, RPacketService::GetNtwkRegStatus, RPacketService::GetStatus, RPacketService::GetAttachMode, RPacketService::NotifyDynamicCapsChange, RPacketService::GetDynamicCaps, RPacketService::NotifyStatusChange

   676  * @SYMTestExpectedResults Pass - Phone automatically attaches to then detaches from packet service.

   677  * @SYMTestType CIT

   678  * @SYMTestCaseDependencies live/automatic

   679  *

   680  * Reason for test: Verify that automatic attach occurs when attach mode is changed to RPacketService::EAttachWhenPossible and automatic detach occurs when attach mode is change to RPacketService::EAttachWhenNeeded. 

   681 

   682 Verify packet network registration status and dynamic caps are correct.

   683  *

   684  * @return - TVerdict code

   685  */

   686 	{

   687 

   688 	//

   689 	// SET UP

   690 	//

   691 

   692 	// Get packet service

   693 	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer,

   694 																	  KMainPhone,

   695 																	  KMainPacketService);

   696 	

   697 	// Get mobile phone

   698 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   699 	

   700 	// Registered with the network

   701 	TInt ret = iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone);

   702 	CHECK_EQUALS_L(ret, KErrNone, 

   703 					_L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed"));

   704 	

   705 	// Ensure attach mode is RPacketService::EAttachWhenNeeded

   706 	RPacketService::TAttachMode attachMode= RPacketService::EAttachWhenNeeded; 

   707 	EnsureAttachModeL(packetService,attachMode);

   708 	

   709 	//

   710 	// SET UP END

   711 	//

   712 

   713 	StartTest();

   714 

   715 	//

   716 	// TEST START

   717 	//

   718 

   719 	

   720 	// Check RPacketService::GetStatus returns RPacketService::EStatusUnattached

   721 	RPacketService::TStatus serviceStatus;

   722 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone,	

   723 					_L("PacketService::GetStatus returned with an error."));

   724 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusUnattached, 

   725 					_L("PacketService::GetStatus did not return RPacketService::EStatusUnattached."));

   726 				

   727 	// Check RPacketService::GetDynamicCaps returns caps in set of RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall

   728 	// Check RPacketService::GetDynamicCaps returns caps NOT in set of RPacketService::KCapsSMSTransfer | RPacketService::KCapsManualDetach | RPacketService::KCapsRxContextActivationReq

   729 	RPacketService::TDynamicCapsFlags dynCaps;

   730 	ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

   731 					_L("PacketService::GetDynamicCaps returned an error"));

   732 	RPacketService::TDynamicCapsFlags expectedCaps = RPacketService::KCapsManualAttach | 

   733 													 RPacketService::KCapsRxCSCall;

   734 	RPacketService::TDynamicCapsFlags unwantedCaps = RPacketService::KCapsSMSTransfer | 

   735 													 RPacketService::KCapsManualDetach | 

   736 													 RPacketService::KCapsRxContextActivationReq;

   737 	ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, 

   738 					_L("PacketService::GetDynamicCaps returned wrong dynamic caps"));

   739 	

   740 	// Post notification for attach mode change

   741 	TExtEtelRequestStatus notifyAttachModeChangeStatus(packetService, EPacketNotifyAttachModeChange);

   742 	CleanupStack::PushL(notifyAttachModeChangeStatus);

   743 	packetService.NotifyAttachModeChange(notifyAttachModeChangeStatus, attachMode);

   744 

   745 	// Post notification for packet service status change

   746 	TExtEtelRequestStatus notifyStatusStatus(packetService, EPacketNotifyStatusChange);

   747 	CleanupStack::PushL(notifyStatusStatus); 

   748 	RPacketService::TStatus packetServiceStatus;

   749 	packetService.NotifyStatusChange(notifyStatusStatus, packetServiceStatus);

   750 	

   751 	// Post notification for dynamic caps change

   752 	TExtEtelRequestStatus notifyDynamicCapsChangeStatus(packetService, EPacketNotifyDynamicCapsChange);

   753 	CleanupStack::PushL(notifyDynamicCapsChangeStatus);

   754 	packetService.NotifyDynamicCapsChange(notifyDynamicCapsChangeStatus, dynCaps);

   755 		

   756 	// Set attach mode to RPacketService::EAttachWhenPossible with RPacketService::SetAttachMode

   757 	TExtEtelRequestStatus setAttachModeStatus(packetService, EPacketSetAttachMode);

   758 	CleanupStack::PushL(setAttachModeStatus);	

   759 	packetService.SetAttachMode(setAttachModeStatus, RPacketService::EAttachWhenPossible);

   760 	ASSERT_EQUALS(WaitForRequestWithTimeOut(setAttachModeStatus, ETimeLong), KErrNone, 

   761 					_L("PacketService::SetAttachMode timed out"));

   762 	ASSERT_EQUALS(setAttachModeStatus.Int(),KErrNone, 

   763 					_L("PacketService::SetAttachMode returned an error."));

   764 		

   765 	// Check RPacketService::NotifyAttachModeChange completes with RPacketService::EAttachWhenPossible

   766 	RPacketService::TAttachMode expectedAttachMode = RPacketService::EAttachWhenPossible;

   767 	iPacketServiceTestHelper.WaitForPacketServiceNotifyAttachModeChange(packetService,

   768 																		notifyAttachModeChangeStatus,

   769 																		attachMode,

   770 																		expectedAttachMode,

   771 																		KErrNone);

   772 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10049);

   773 	

   774 	// Check RPacketService::GetAttachMode returns RPacketService::EAttachWhenPossible

   775 	TExtEtelRequestStatus getAttachModeStatus (packetService,EPacketGetAttachMode);

   776 	CleanupStack::PushL(getAttachModeStatus);	

   777 	packetService.GetAttachMode(getAttachModeStatus, attachMode);

   778 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeMedium), KErrNone,

   779 					_L("PacketService::GetAttachMode timed out"));

   780 	ASSERT_EQUALS(getAttachModeStatus.Int(),KErrNone, 

   781 					_L("PacketService::GetAttachMode returned an error"));

   782 	ASSERT_EQUALS(attachMode, RPacketService::EAttachWhenPossible, 

   783 					_L("PacketService::GetAttachMode Wrong attach mode"));

   784 

   785 	// Check RPacketService::NotifyStatusChange completes with RPacketService::EStatusAttached

   786 	RPacketService::TStatus expectedPacketServiceStatus = RPacketService::EStatusAttached;

   787 	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService, 

   788 																	notifyStatusStatus,

   789 																	packetServiceStatus,

   790 																	expectedPacketServiceStatus,

   791 																	KErrNone);

   792 			

   793 	// Check RPacketService::NotifyDynamicCapsChange completes with KCapsActivate | KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer

   794 	// Check RPacketService::NotifyDynamicCapsChange completes with caps NOT in set of RPacketService::KCapsManualAttach

   795 	expectedCaps = 	RPacketService::KCapsRxCSCall | 

   796 					RPacketService::KCapsRxContextActivationReq | 

   797 					RPacketService::KCapsManualDetach | 

   798 					RPacketService::KCapsSMSTransfer;

   799 	unwantedCaps =  RPacketService::KCapsManualAttach;

   800 	iPacketServiceTestHelper.WaitForPacketServiceNotifyDynamicCapsChange(packetService,

   801 																		 notifyDynamicCapsChangeStatus,

   802 																		 dynCaps,

   803 																		 expectedCaps,

   804 																		 unwantedCaps,

   805 																		 KErrNone);

   806 

   807 	// Check RPacketService::GetStatus returns RPacketService::EStatusAttached

   808 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone,	

   809 					_L("PacketService::GetStatus returned an error"));

   810 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusAttached, 

   811 					_L("PacketService::GetStatus did not return RPacketService::EStatusAttached"));

   812 	

   813 	// Check RPacketService::GetDynamicCaps returns caps in set of KCapsActivate | KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer.

   814 	// Check RPacketService::GetDynamicCaps completes with caps NOT in set of RPacketService::KCapsManualAttach

   815     ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

   816 					_L("PacketService::GetDynamicCaps returned an error"));

   817     expectedCaps = 	RPacketService::KCapsRxCSCall | 

   818     				RPacketService::KCapsRxContextActivationReq | 

   819     				RPacketService::KCapsManualDetach | 

   820     				RPacketService::KCapsSMSTransfer;

   821     unwantedCaps = 	RPacketService::KCapsManualAttach;

   822     ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, 

   823 					_L("PacketService::GetDynamicCaps Wrong dynamic caps"));

   824     

   825 	// Check RPacketService::GetNtwkRegStatus returns ENotRegisteredOnHomeNetwork

   826 	TExtEtelRequestStatus regStatus(packetService, EPacketGetNtwkRegStatus);

   827 	CleanupStack::PushL(regStatus);

   828 	RPacketService::TRegistrationStatus registrationStatus;

   829 	packetService.GetNtwkRegStatus(regStatus, registrationStatus);

   830 	ASSERT_EQUALS(WaitForRequestWithTimeOut(regStatus, ETimeMedium),KErrNone, 

   831 					_L("PacketService::GetNtwkRegStatus timed out"));

   832 	ASSERT_EQUALS(regStatus.Int(), KErrNone, 

   833 	    			_L("PacketService::GetNtwkRegStatus returned an error"));

   834 	ASSERT_EQUALS(registrationStatus, RPacketService::ERegisteredOnHomeNetwork,

   835 					_L("PacketService::GetNtwkRegStatus did not return RPacketService::ERegisteredOnHomeNetwork registration status"));

   836 	// $CTSYProblem: After EStatusUnattached staus, ENotRegisteredButAvailable registration status of network was not achieved as expected.

   837 	// This problem occurs when once you register with the network then it remains registered even when we expect not registered.

   838 	

   839 	// Post notification for RPacketService::NotifyAttachModeChange 

   840 	packetService.NotifyAttachModeChange(notifyAttachModeChangeStatus, attachMode);

   841 

   842 	// Post notification for packet service status change

   843 	packetService.NotifyStatusChange(notifyStatusStatus, packetServiceStatus);

   844 

   845 	// Post notification for dynamic caps change

   846 	packetService.NotifyDynamicCapsChange(notifyDynamicCapsChangeStatus, dynCaps);

   847 	    		

   848 	// Set attach mode to RPacketService::EAttachWhenNeeded with RPacketService::SetAttachMode

   849 	packetService.SetAttachMode(setAttachModeStatus, RPacketService::EAttachWhenNeeded);

   850 	ASSERT_EQUALS(WaitForRequestWithTimeOut(setAttachModeStatus, ETimeMedium), KErrNone,

   851 					_L("PacketService::SetAttachMode timed out."));

   852 	ASSERT_EQUALS(setAttachModeStatus.Int(),KErrNone, 

   853 					_L("PacketService::SetAttachMode returned an error"));

   854 		

   855 	// Check RPacketService::NotifyAttachModeChange completes with RPacketService::EAttachWhenNeeded

   856 	expectedAttachMode = RPacketService::EAttachWhenNeeded;

   857 	iPacketServiceTestHelper.WaitForPacketServiceNotifyAttachModeChange(packetService,

   858 																		notifyAttachModeChangeStatus,

   859 																		attachMode,

   860 																		expectedAttachMode,

   861 																		KErrNone);

   862 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10049);

   863 	

   864 	// Check RPacketService::GetAttachMode returns RPacketService::EAttachWhenNeeded

   865 	packetService.GetAttachMode(getAttachModeStatus, attachMode);

   866 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeMedium), KErrNone,

   867 					_L("PacketService::GetAttachMode timed out"));

   868 	ASSERT_EQUALS(getAttachModeStatus.Int(),KErrNone, 

   869 					_L("PacketService::GetAttachMode returned an error."));

   870 	ASSERT_EQUALS(attachMode, RPacketService::EAttachWhenNeeded, 

   871 					_L("PacketService::GetAttachMode did not return RPacketService::EAttachWhenNeeded"));

   872 	

   873 	// Check RPacketService::NotifyStatusChange completes with RPacketService::EStatusUnattached

   874 	expectedPacketServiceStatus = RPacketService::EStatusUnattached;

   875 	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService, 

   876 																	notifyStatusStatus,

   877 																	packetServiceStatus,

   878 																	expectedPacketServiceStatus,

   879 																	KErrNone);	

   880 			

   881 	// Check RPacketService::NotifyDynamicCapsChange completes with caps in set of RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall

   882 	// Check RPacketService::NotifyDynamicCapsChange completes with caps NOT in set of RPacketService::KCapsSMSTransfer | RPacketService::KCapsManualDetach | RPacketService::KCapsRxContextActivationReq

   883 	expectedCaps = 	RPacketService::KCapsManualAttach | 

   884 					RPacketService::KCapsRxCSCall;

   885 	unwantedCaps =  RPacketService::KCapsSMSTransfer | 

   886 				    RPacketService::KCapsManualDetach | 

   887 				    RPacketService::KCapsRxContextActivationReq;

   888    	iPacketServiceTestHelper.WaitForPacketServiceNotifyDynamicCapsChange(packetService,

   889 																		 notifyDynamicCapsChangeStatus,

   890 																		 dynCaps,

   891 																		 expectedCaps,

   892 																		 unwantedCaps,

   893 																		 KErrNone);

   894 

   895 	// Check RPacketService::GetStatus returns RPacketService::EStatusUnattached

   896 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone,	

   897 					_L("PacketService::GetStatus returned an error"));

   898 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusUnattached, 

   899 					_L("PacketService::GetStatus did not return RPacketService::EStatusUnattached"));

   900 	

   901 	// Check RPacketService::GetDynamicCaps returns caps in set of RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall

   902 	// Check RPacketService::GetDynamicCaps returns caps NOT in set of RPacketService::KCapsSMSTransfer | RPacketService::KCapsManualDetach | RPacketService::KCapsRxContextActivationReq

   903     ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

   904 					_L("PacketService::GetDynamicCaps returned an error"));	

   905     expectedCaps = 	RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall;

   906     unwantedCaps = 	RPacketService::KCapsSMSTransfer | 

   907     			    RPacketService::KCapsManualDetach | 

   908     			    RPacketService::KCapsRxContextActivationReq;

   909     ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, _L("PacketService::GetDynamicCaps returned wrong dynamic caps"));

   910     

   911     DEBUG_PRINTF1(_L("<font color=Orange>$CTSYProblem: After EStatusUnattached staus, ENotRegisteredButAvailable registration status of network was not achieved\n as expected. This problem occurs when once you register with the network then it remains registered even when we expect not registered.</font> "));

   912 	// Check RPacketService::GetNtwkRegStatus returns ENotRegisteredOnHomeNetwork

   913 	packetService.GetNtwkRegStatus(regStatus, registrationStatus);

   914 	ASSERT_EQUALS(WaitForRequestWithTimeOut(regStatus, ETimeLong),KErrNone, 

   915 					_L("PacketService::GetNtwkRegStatus timed out"));

   916 	ASSERT_EQUALS(regStatus.Int(), KErrNone, 

   917 	    			_L("PacketService::GetNtwkRegStatus returned an error"));

   918 	ASSERT_EQUALS(registrationStatus, RPacketService::ERegisteredOnHomeNetwork, 

   919 	    			_L("PacketService::GetNtwkRegStatus did not return RPacketService::ERegisteredOnHomeNetwork registration status"));

   920 	

   921 	//

   922 	// TEST END

   923 	//

   924 

   925 	StartCleanup();

   926 	

   927 	// Pop:

   928 	// notifyAttachModeChangeStatus

   929     // notifyStatusStatus, 

   930     // notifyDynamicCapsChangeStatus

   931 	// setAttachModeStatus

   932 	// getAttachModeStatus

   933 	// regStatus

   934 	CleanupStack::PopAndDestroy(6,&notifyAttachModeChangeStatus);

   935 	

   936 	return TestStepResult();

   937 	}

   938 

   939 TPtrC CCTSYIntegrationTestPacketService0004::GetTestStepName()

   940 /**

   941  * @return The test step name.

   942  */

   943 	{

   944 	return _L("CCTSYIntegrationTestPacketService0004");

   945 	}

   946 

   947 

   948 

   949 CCTSYIntegrationTestPacketService0005::CCTSYIntegrationTestPacketService0005(CEtelSessionMgr& aEtelSessionMgr)

   950 	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

   951 /**

   952  * Constructor.

   953  */

   954 	{

   955 	SetTestStepName(CCTSYIntegrationTestPacketService0005::GetTestStepName());

   956 	}

   957 

   958 CCTSYIntegrationTestPacketService0005::~CCTSYIntegrationTestPacketService0005()

   959 /**

   960  * Destructor.

   961  */

   962 	{

   963 	}

   964 

   965 TVerdict CCTSYIntegrationTestPacketService0005::doTestStepL()

   966 /**

   967  * @SYMTestCaseID BA-CTSY-INT-PKTS-0005

   968  * @SYMFssID BA/CTSY/PKTS-0005

   969  * @SYMTestCaseDesc Attach to the packet service manually.

   970  * @SYMTestPriority High

   971  * @SYMTestActions RPacketService::GetNtwkRegStatus, RPacketService::GetStatus, RPacketService::GetAttachMode, RPacketService::NotifyDynamicCapsChange, RPacketService::GetDynamicCaps, RPacketService::NotifyStatusChange

   972  * @SYMTestExpectedResults Pass - Phone attached to packet service.

   973  * @SYMTestType CIT

   974  * @SYMTestCaseDependencies live/automatic

   975  *

   976  * Reason for test: Verify packet service can be manually attached and phone is registered on packet network when attach mode is EAttachWhenNeeded.

   977 

   978 Verify packet network registration status, attach mode, dynamic caps are correct.

   979  *

   980  * @return - TVerdict code

   981  */

   982 	{

   983 	

   984 	//

   985 	// SET UP

   986 	//

   987 

   988 	

   989 	// Get packet service

   990 	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer,

   991 																	  KMainPhone,

   992 																	  KMainPacketService);

   993 	

   994 	// Get mobile phone

   995 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   996 	

   997 	// Ensure attach mode is RPacketService::EAttachWhenNeeded	

   998 	RPacketService::TAttachMode attachMode= RPacketService::EAttachWhenNeeded; 

   999 	EnsureAttachModeL(packetService,attachMode);

  1000 	//

  1001 	// SET UP END

  1002 	//

  1003 	

  1004 	StartTest();

  1005 	

  1006 	//

  1007 	// TEST START

  1008 	//

  1009 

  1010 	// Post notification for packet service status change

  1011 	TExtEtelRequestStatus notifyStatusStatus(packetService, EPacketNotifyStatusChange);

  1012 	CleanupStack::PushL(notifyStatusStatus); 

  1013 	RPacketService::TStatus packetServiceStatus;

  1014 	packetService.NotifyStatusChange(notifyStatusStatus, packetServiceStatus);

  1015 	

  1016 	// Post notification for dynamic caps change

  1017 	RPacketService::TDynamicCapsFlags dynCaps;

  1018 	TExtEtelRequestStatus notifyDynamicCapsChangeStatus(packetService, EPacketNotifyDynamicCapsChange);

  1019 	CleanupStack::PushL(notifyDynamicCapsChangeStatus);

  1020 	packetService.NotifyDynamicCapsChange(notifyDynamicCapsChangeStatus, dynCaps);

  1021 

  1022 	// Check RPacketService::GetAttachMode returns RPacketService::EAttachWhenNeeded.

  1023 	TExtEtelRequestStatus getAttachModeStatus (packetService,EPacketGetAttachMode);	

  1024 	CleanupStack::PushL(getAttachModeStatus);

  1025 	packetService.GetAttachMode(getAttachModeStatus, attachMode);

  1026 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeMedium), KErrNone, 

  1027 					_L("PacketService::GetAttachMode timed out."));

  1028 	ASSERT_EQUALS(getAttachModeStatus.Int(),KErrNone, 

  1029 					_L("PacketService::GetAttachMode returned an error"));

  1030 	ASSERT_EQUALS(attachMode, RPacketService::EAttachWhenNeeded, 

  1031 					_L("PacketService::GetAttachMode did not return RPacketService::EAttachWhenNeeded"));

  1032 	

  1033 	// Check RPacketService::GetStatus returns RPacketService::EStatusUnattached.

  1034 	RPacketService::TStatus serviceStatus;

  1035 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone,

  1036 					_L("PacketService::GetStatus returned with an error."));

  1037 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusUnattached, 

  1038 					_L("PacketService::GetStatus did not return RPacketService::EStatusUnattached."));

  1039 				

  1040 	// Check RPacketService::GetNtwkRegStatus returns RPacketService::ENotRegisteredButAvailable

  1041     TExtEtelRequestStatus regStatus(packetService, EPacketGetNtwkRegStatus);

  1042 	CleanupStack::PushL(regStatus);

  1043     RPacketService::TRegistrationStatus registrationStatus;

  1044     packetService.GetNtwkRegStatus(regStatus, registrationStatus);

  1045 	ASSERT_EQUALS(WaitForRequestWithTimeOut(regStatus, ETimeLong), KErrNone, 

  1046 					_L("PacketService::GetNtwkRegStatus timed out."));

  1047     ASSERT_EQUALS(regStatus.Int(),KErrNone, 

  1048 					_L("PacketService::GetNtwkRegStatus returned an error"));

  1049     ASSERT_EQUALS(registrationStatus, RPacketService::ERegisteredOnHomeNetwork, 

  1050     				_L("PacketService::GetNtwkRegStatus did not return RPacketService::ENotRegisteredButAvailable"));

  1051     DEBUG_PRINTF1(_L("<font color=Orange>$CTSYProblem: After EStatusUnattached staus, ENotRegisteredButAvailable registration status of network was not achieved\n as expected. This problem occurs when once you register with the network then it remains registered even when we expect not registered.</font> "));	

  1052     

  1053 	// Registered with the network

  1054 	TInt ret = iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone);

  1055 	ASSERT_EQUALS(ret, KErrNone, 

  1056 					_L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed"));

  1057 			

  1058 	// Check RPacketService::GetDynamicCaps returns caps RPacketService::KCapsManualAttach | KCapsRxCSCall.

  1059 	// Check RPacketService::GetDynamicCaps returns caps NOT in set of RPacketService::KCapsSMSTransfer | RPacketService::KCapsManualDetach | RPacketService::KCapsRxContextActivationReq;

  1060 	ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

  1061 					_L("PacketService::GetDynamicCaps returned an error"));

  1062 	RPacketService::TDynamicCapsFlags expectedCaps = 

  1063 					RPacketService::KCapsManualAttach | 

  1064 					RPacketService::KCapsRxCSCall;

  1065 	RPacketService::TDynamicCapsFlags unwantedCaps = 

  1066 					RPacketService::KCapsSMSTransfer | 

  1067 					RPacketService::KCapsManualDetach | 

  1068 					RPacketService::KCapsRxContextActivationReq;

  1069 	ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, 

  1070 				_L("PacketService::GetDynamicCaps returned wrong dynamic caps"));

  1071 

  1072 	// Attach to packet network

  1073 	TExtEtelRequestStatus attachStatus(packetService, EPacketAttach);

  1074 	CleanupStack::PushL(attachStatus);

  1075 	packetService.Attach(attachStatus);

  1076 	ASSERT_EQUALS(WaitForRequestWithTimeOut(attachStatus, ETimeLong), KErrNone,

  1077 					_L("PacketService::Attach timed out."));

  1078 	ASSERT_EQUALS(attachStatus.Int(), KErrNone, 

  1079 					_L("PacketService::Attach returned an error"));

  1080  

  1081 	// Check RPacketService::NotifyStatusChange completes with EStatusAttached.

  1082 	RPacketService::TStatus expectedPacketServiceStatus = RPacketService::EStatusAttached;

  1083 	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService, 

  1084 																	notifyStatusStatus,

  1085 																	packetServiceStatus,

  1086 																	expectedPacketServiceStatus,

  1087 																	KErrNone);	

  1088 	

  1089 	// Check RPacketService::NotifyDynamicCapsChange completes with caps in set of KCapsActivate | KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer.

  1090 	// Check RPacketService::NotifyDynamicCapsChange completes with caps NOT in set of RPacketService::KCapsManualAttach

  1091 	expectedCaps = 	RPacketService::KCapsRxCSCall |

  1092 	 				RPacketService::KCapsRxContextActivationReq |

  1093 	 				RPacketService::KCapsManualDetach |

  1094 	 				RPacketService::KCapsSMSTransfer;

  1095 	unwantedCaps = RPacketService::KCapsManualAttach;

  1096    	iPacketServiceTestHelper.WaitForPacketServiceNotifyDynamicCapsChange(packetService,

  1097    																		 notifyDynamicCapsChangeStatus,

  1098    																		 dynCaps,

  1099    																		 expectedCaps,

  1100    																		 unwantedCaps,

  1101    																		 KErrNone);

  1102 					

  1103 	// Check RPacketService::GetStatus returns EStatusAttached.

  1104 	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone, 

  1105 					_L("PacketService::GetStatus returned with an error."));

  1106 	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusAttached, 

  1107 					_L("PacketService::GetStatus did not return RPacketService::EStatusAttached."));

  1108 				

  1109 	// Check RPacketService::GetNtwkRegStatus returns ERegisteredOnHomeNetwork.

  1110     packetService.GetNtwkRegStatus(regStatus, registrationStatus);

  1111 	ASSERT_EQUALS(WaitForRequestWithTimeOut(regStatus, ETimeMedium), KErrNone,

  1112 					_L("PacketService::GetNtwkRegStatus timed out."));

  1113     ASSERT_EQUALS(regStatus.Int(),KErrNone, 

  1114 					_L("PacketService::GetNtwkRegStatus returned an error"));

  1115     ASSERT_EQUALS(registrationStatus, RPacketService::ERegisteredOnHomeNetwork,	

  1116 					_L("PacketService::GetNtwkRegStatus returned wrong registration status"));

  1117     			

  1118 	// Check RPacketService::GetDynamicCaps returns caps in set of KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer.

  1119 	// Check RPacketService::GetDynamicCaps returns caps NOT in set of RPacketService::KCapsManualAttach

  1120     ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

  1121 					_L("PacketService::GetDynamicCaps returned an error"));

  1122     expectedCaps = 	RPacketService::KCapsRxCSCall | 

  1123     				RPacketService::KCapsRxContextActivationReq | 

  1124     				RPacketService::KCapsManualDetach | 

  1125     				RPacketService::KCapsSMSTransfer;

  1126     unwantedCaps = 	RPacketService::KCapsManualAttach;

  1127     ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, 

  1128 				_L("PacketService::GetDynamicCaps returned wrong dynamic caps"));

  1129  

  1130     //

  1131     // Test end

  1132     //

  1133     		

  1134     StartCleanup();

  1135