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 NetworkControl functional unit.

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include <etelpckt.h>

    23 #include <pcktcs.h>

    24  

    25 #include "cctsyintegrationtestnetworkcontrol.h"

    26 #include "listretrievalhelpers.h"

    27 #include "cctsyinidata.h"

    28 

    29 	

    30 CCTSYIntegrationTestNetworkControlBase::CCTSYIntegrationTestNetworkControlBase(CEtelSessionMgr& aEtelSessionMgr)

    31 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), 

    32 		iNetworkTestHelper(*this),

    33 		iCallControlTestHelper(*this),

    34 		iPacketServiceTestHelper(*this)

    35 		

    36 /**

    37  * Constructor

    38  */

    39 	{

    40 	}

    41 

    42 CCTSYIntegrationTestNetworkControlBase::~CCTSYIntegrationTestNetworkControlBase()

    43 /*

    44  * Destructor

    45  */

    46 	{

    47 	}

    48 			

    49 

    50 /** 

    51 * Check a preferred network entry is in the list

    52 * 

    53 * @param aList The list to search.

    54 * @param aTarget The network to search for in aList.

    55 * 

    56 * @return ETrue if aTarget is found in aList, EFalse otherwise.

    57 */

    58 TBool CCTSYIntegrationTestNetworkControlBase::IsPreferredNetworkInListL( 

    59 								CMobilePhoneStoredNetworkList& aList, 

    60 								RMobilePhone::TMobilePreferredNetworkEntryV3& aTarget)

    61 	{

    62 	TInt listCount = aList.Enumerate(); 

    63 

    64 	for( TInt i=0; i < listCount; i++ )

    65 		{

    66 		const RMobilePhone::TMobilePreferredNetworkEntryV3 &netInfo = aList.GetEntryL(i);

    67 		

    68 		if( netInfo.iAccess == aTarget.iAccess && 

    69 			netInfo.iCountryCode == aTarget.iCountryCode &&

    70 			netInfo.iNetworkId == aTarget.iNetworkId )

    71 			{

    72 			return ETrue;

    73 			}

    74 		}

    75 	

    76 	return EFalse;

    77 	

    78 	}

    79 

    80 void CCTSYIntegrationTestNetworkControlBase::SetAttachModeToWhenPossibleAndWaitForAttachL(RPacketService& aPacketService)

    81 /**

    82  * Attaches the phone to the packet service by setting the

    83  * attach mode to RPacketService::EAttachWhenPossible. Requests

    84  * that the phone attaches to the packet service and waits for

    85  * attach to complete.

    86  * 

    87  * @param aPacketService Reference to packet service subsession.

    88  */

    89     {

    90     RPacketService::TAttachMode attachMode;

    91     CHECK_EQUALS_L(aPacketService.GetAttachMode(attachMode), KErrNone, _L("RPacketService::GetAttachMode returned with an error."));

    92 

    93     TExtEtelRequestStatus notifyServiceStatusChStatus(aPacketService, EPacketNotifyStatusChange);

    94     CleanupStack::PushL(notifyServiceStatusChStatus);

    95     RPacketService::TStatus packetServiceStatus;

    96     aPacketService.NotifyStatusChange(notifyServiceStatusChStatus, packetServiceStatus);

    97 

    98     if(attachMode != RPacketService::EAttachWhenPossible)

    99 		{

   100 		CHECK_EQUALS_L(aPacketService.SetAttachMode(RPacketService::EAttachWhenPossible), KErrNone,

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

   102 		}

   103 

   104     CHECK_EQUALS_L(aPacketService.GetAttachMode(attachMode), KErrNone, _L("RPacketService::GetAttachMode returned with an error."));

   105     CHECK_EQUALS_L(attachMode, RPacketService::EAttachWhenPossible, _L("RPacketService::GetAttachMode did not return EAttachWhenPossible."));

   106 

   107     // Ensure phone is attached to the packet service (RPacketService::GetStatus returns EStatusAttached).

   108 	RPacketService::TStatus packetStatus;

   109 	CHECK_EQUALS_L(aPacketService.GetStatus(packetStatus), KErrNone, _L("RPacketService::GetStatus returned with an error"));

   110 	

   111 	// Wait for phone to attach to packet service if it is not attached.

   112 	if (packetStatus == RPacketService::EStatusUnattached)

   113 		{

   114         iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(

   115 				aPacketService,

   116 				notifyServiceStatusChStatus,

   117 				packetServiceStatus, 

   118 				RPacketService::EStatusAttached,

   119 				KErrNone);

   120         CHECK_EQUALS_L(aPacketService.GetStatus(packetStatus), KErrNone, _L("RPacketService::GetStatus returned with an error"));

   121         CHECK_EQUALS_L(packetStatus, RPacketService::EStatusAttached, _L("RPacketService::GetStatus did not return EStatusAttached"));

   122 		}

   123 

   124     CleanupStack::PopAndDestroy(1, &notifyServiceStatusChStatus);

   125     }

   126 	

   127 /**************************************************************************/

   128 

   129 CCTSYIntegrationTestNetworkControl0001::CCTSYIntegrationTestNetworkControl0001(CEtelSessionMgr& aEtelSessionMgr)

   130 	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

   131 /**

   132  * Constructor.

   133  */

   134 	{

   135 	SetTestStepName(CCTSYIntegrationTestNetworkControl0001::GetTestStepName());

   136 	}

   137 

   138 CCTSYIntegrationTestNetworkControl0001::~CCTSYIntegrationTestNetworkControl0001()

   139 /**

   140  * Destructor.

   141  */

   142 	{

   143 	}

   144 

   145 TVerdict CCTSYIntegrationTestNetworkControl0001::doTestStepL()

   146 /**

   147  * @SYMTestCaseID BA-CTSY-INT-NTWC-0001

   148  * @SYMFssID BA/CTSY/NTWC-0001

   149  * @SYMTestCaseDesc Manually select home and non-home network.

   150 

   151  * @SYMTestPriority High

   152  * @SYMTestActions CRetrieveMobilePhonePreferredNetworks::NewL, RMobilePhone::SelectNetwork, RMobilePhone::StorePreferredNetworksListL, RMobilePhone::SetNetworkSelectionSetting, RMobilePhone::GetNetworkSelectionSetting, RMobilePhone::NotifyNetworkSelectionSettingChange

   153  * @SYMTestExpectedResults Pass - Can register onto home network and this does not change preferred network list.

   154  * @SYMTestType CIT

   155  * @SYMTestCaseDependencies live/automatic

   156  *

   157  * Reason for test: Verify home network can be selected, non-home network cannot be selected and preferred network list does not change after manual network selection.

   158  *

   159  * @return - TVerdict code

   160  */

   161 	{

   162 

   163 	//

   164 	// SET UP

   165 	//

   166 	

   167 	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   168 	

   169 	iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone);

   170 	

   171 	// Ensure that RMobilePhone::GetNetworkCaps returns caps in set of KCapsGetDetectedNetworks | KCapsManualNetworkSelection 

   172 	TUint32 caps;

   173 	CHECK_EQUALS_L( phone.GetNetworkCaps( caps ), KErrNone, _L("RMobilePhone::GetNetworkCaps returned an error") );

   174 	TUint32 wantedCaps = RMobilePhone::KCapsGetDetectedNetworks | RMobilePhone::KCapsManualNetworkSelection;

   175 	CHECK_BITS_SET_L( caps, wantedCaps, KNoUnwantedBits, _L("RMobilePhone::GetNetworkCaps returned wrong caps") );

   176 	

   177 	// Ensure RMobilePhone::GetNetworkSelectionSetting returns aSetting.iMethod = ENetworkSelectionAutomatic 

   178 	RMobilePhone::TMobilePhoneNetworkSelectionV1 netSelSetting;

   179 	RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg netSelSettingPkg(netSelSetting);

   180 		

   181 	CHECK_EQUALS_L( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

   182 		_L("RMobilePhone::GetNetworkSelectionSetting returned an error") );

   183 	

   184 	if (netSelSetting.iMethod != RMobilePhone::ENetworkSelectionAutomatic)

   185 		{

   186 		DEBUG_PRINTF1(_L("Setting network selection setting to auto"));

   187 		TExtEtelRequestStatus setNetSelSettingStatus(phone, EMobilePhoneSetNetworkSelectionSetting);

   188 		CleanupStack::PushL(setNetSelSettingStatus);

   189 		netSelSetting.iMethod = RMobilePhone::ENetworkSelectionAutomatic;

   190 		phone.SetNetworkSelectionSetting( setNetSelSettingStatus, netSelSettingPkg );

   191 		

   192 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setNetSelSettingStatus, ETimeLong), KErrNone, 

   193 						_L("RMobilePhone::SetNetworkSelectionSetting timed out") );

   194 		CHECK_EQUALS_L( setNetSelSettingStatus.Int(), KErrNone, 

   195 						_L("RMobilePhone::SetNetworkSelectionSetting returned error") );

   196 		

   197 		CleanupStack::Pop(&setNetSelSettingStatus);

   198 		}

   199 

   200 	CHECK_EQUALS_L( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

   201 			_L("RMobilePhone::GetNetworkSelectionSetting returned an error") );

   202 	CHECK_EQUALS_L( netSelSetting.iMethod, RMobilePhone::ENetworkSelectionAutomatic, 

   203 		_L("RMobilePhone::GetNetworkSelectionSetting - TMobilePhoneNetworkSelectionV1::iMethod was not ENetworkSelectionAutomatic") );

   204 								

   205 	//

   206 	// SET UP END

   207 	//

   208 	

   209 	StartTest();

   210 	

   211 	//

   212 	// TEST START

   213 	//

   214 	

   215 	// ===  Get the ID and country code of the home network and store it for use later ===

   216 	RMobilePhone::TMobilePhoneNetworkInfoV1 homeNetworkInfo;

   217 	TPckg<RMobilePhone::TMobilePhoneNetworkInfoV1> homeInfoPkg(homeNetworkInfo);	

   218 	TExtEtelRequestStatus getHomeNetworkStatus(phone, EMobilePhoneGetHomeNetwork);

   219 	CleanupStack::PushL(getHomeNetworkStatus);

   220 	phone.GetHomeNetwork( getHomeNetworkStatus, homeInfoPkg );

   221 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getHomeNetworkStatus, ETimeLong), KErrNone, 

   222 			_L("RMobilePhone::GetHomeNetwork timed out") );

   223 	ASSERT_EQUALS( getHomeNetworkStatus.Int(), KErrNone, _L("TNetworkTsyTestHelper::GetHomeNetworkL returned an error") );

   224 

   225 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV1 returns aNetworkInfo.iNetworkId with length > 0

   226 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV1 returns aNetworkInfo.iCountryCode with length > 0

   227 	

   228 	ASSERT_TRUE( homeNetworkInfo.iNetworkId.Length() > 0, 

   229 							_L("RMobilePhone::GetHomeNetwork returned aNetworkInfo.iNetworkId <= 0"));

   230 	ASSERT_TRUE( homeNetworkInfo.iCountryCode.Length() > 0, 

   231 							_L("RMobilePhone::GetHomeNetwork returned aNetworkInfo.iCountryCode <= 0"));

   232 

   233 	// ===  Put the phone into manual network selection mode. ===

   234 	

   235 	// Set up the RMobilePhone::NotifyNetworkSelectionSettingChange notification for later test

   236 	TExtEtelRequestStatus notifyNetSelSettingChange( phone, EMobilePhoneNotifyNetworkSelectionSettingChange);

   237 	CleanupStack::PushL(notifyNetSelSettingChange);

   238 	

   239 	RMobilePhone::TMobilePhoneNetworkSelectionV1 netSelNotify;

   240 	RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg netSelNotifyPkg( netSelNotify );

   241 	phone.NotifyNetworkSelectionSettingChange(notifyNetSelSettingChange, netSelNotifyPkg);

   242 	

   243 	// Set network selection setting to manual with RMobilePhone::SetNetworkSelectionSetting with 

   244 	// aSetting.iMethod = ENetworkSelectionManual

   245 	TExtEtelRequestStatus setNetSelSettingStatus(phone, EMobilePhoneSetNetworkSelectionSetting);

   246 	CleanupStack::PushL(setNetSelSettingStatus);

   247 	netSelSetting.iMethod = RMobilePhone::ENetworkSelectionManual;

   248 	phone.SetNetworkSelectionSetting( setNetSelSettingStatus, netSelSettingPkg );

   249 	

   250 	ASSERT_EQUALS(WaitForRequestWithTimeOut(setNetSelSettingStatus, ETimeLong), KErrNone, 

   251 					_L("RMobilePhone::SetNetworkSelectionSetting timed out") );

   252 	ASSERT_EQUALS( setNetSelSettingStatus.Int(), KErrNone, 

   253 					_L("RMobilePhone::SetNetworkSelectionSetting returned error") );					

   254 	

   255 	// ===  Verify manual selection mode has been set and notification received ===

   256 

   257 	// Check RMobilePhone::NotifyNetworkSelectionSettingChange completes with 

   258 	// aSetting.iMethod = ENetworkSelectionManual

   259 	iNetworkTestHelper.WaitForMobilePhoneNotifyNetworkSelectionSettingChange(phone,

   260 													notifyNetSelSettingChange,netSelNotify, 

   261 													RMobilePhone::ENetworkSelectionManual, KErrNone);

   262 

   263 	// Check RMobilePhone::GetNetworkSelectionSetting returns aSetting.iMethod = ENetworkSelectionManual

   264 	ASSERT_EQUALS( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

   265 						_L("RMobilePhone::GetNetworkSelectionSetting returned an error") );

   266 	ASSERT_EQUALS( netSelSetting.iMethod, RMobilePhone::ENetworkSelectionManual, 

   267 							_L("RMobilePhone::GetNetworkSelectionSetting returned method is not ENetworkSelectionManual") );

   268 

   269 	// ===  Get and store (locally) the list of preferred networks for use later ===

   270 

   271 	// Use helper class for CRetrieveMobilePhonePreferredNetworks to retrieve a list of preferred networks 

   272 	// Store list for use later. 

   273 	

   274 	CRetrieveMobilePhonePreferredNetworksExec *netListHelper = CRetrieveMobilePhonePreferredNetworksHelper::NewL(phone);

   275 	CleanupStack::PushL( netListHelper );

   276 	TInt err;

   277 	CMobilePhoneStoredNetworkList* prefNetList = netListHelper->DoGetList(err);

   278 	ASSERT_EQUALS(err, KErrNotSupported, _L("CRetrieveMobilePhonePreferredNetworks::Start failed to get the list"));	

   279 

   280 	// ===  Get List of detected networks and ensure that this list contain at least 2 networks ===

   281 	// (the home network and an other one).

   282 	// Use helper class for CRetrieveMobilePhoneDetectedNetworks to retrieve a list of detected networks 

   283 	CRetrieveMobilePhoneDetectedNetworksExec *detectedNetListHelper = 

   284 				CRetrieveMobilePhoneDetectedNetworksHelper::NewL(phone,ERetrieveListV1);

   285 	

   286 	CMobilePhoneNetworkList *detectedNetList = detectedNetListHelper->DoGetList(err);

   287 	

   288 	ASSERT_EQUALS(err, KErrNotSupported, _L("CRetrieveMobilePhoneDetectedNetworks::Start failed to get the list"));

   289 

   290 	// $CTSYProblem CTSY does not support EMobilePhoneGetPreferredNetworksPhase1 and 

   291 	// EMobilePhoneGetDetectedNetworksPhase1 IPCs.

   292 	// If supported for these are added, the rest of this test can be uncommented

   293 	// and the CleanupStack items sorted out.

   294 	

   295 	/*	

   296 	TInt detectedNetCount = detectedNetList->Enumerate();

   297 	DEBUG_PRINTF2(_L("CRetrieveMobilePhoneDetectedNetworks returned list of %d entries"), detectedNetCount );

   298 	ASSERT_TRUE(detectedNetCount >= 2, _L("CRetrieveMobilePhoneDetectedNetworks returned list of < 2 entries"));

   299 	

   300 	// Cycle through the items in CMobilePhoneNetworkList list and find a network which 

   301 	// is not the home network (TMobilePhoneNetworkInfoV1::iNetworkId in the list != aNetworkInfo.iNetworkId 

   302 	// from RMobilePhone::GetHomeNetwork)

   303 	const RMobilePhone::TMobilePhoneNetworkInfoV1 *notHomeNetworkInfo = NULL;

   304 	for( TInt i=0; i < detectedNetCount; i++ )

   305 		{

   306 		const RMobilePhone::TMobilePhoneNetworkInfoV1 &netInfo = detectedNetList->GetEntryL(i);

   307 		if( netInfo.iNetworkId != homeNetworkInfo.iNetworkId )

   308 			{

   309 			notHomeNetworkInfo = &netInfo;

   310 			break;

   311 			}

   312 		}

   313 	

   314 	// ===  When a non-home network has been found, try to select it ===

   315 	ASSERT_TRUE( NULL != notHomeNetworkInfo, _L("Failed to find a non-home network") );

   316 	TEST_CHECK_POINT_L( _L("Failed to find a non-home network, leaving") );

   317 

   318 	//  Select network with RMobilePhone::SelectNetwork with 

   319 	// aIsManual=ETrue and 

   320 	// aManualSelection.iCountry=TMobilePhoneNetworkInfoV1::iCountryCode and 

   321 	// aManualSelection.iNetwork=TMobilePhoneNetworkInfoV1::iNetworkId 

   322 	

   323 	TExtEtelRequestStatus reqSetNetworkStatus(phone, EMobilePhoneSelectNetwork);

   324 	CleanupStack::PushL(reqSetNetworkStatus);	

   325 	RMobilePhone::TMobilePhoneNetworkManualSelection manNetSel;

   326 

   327 	manNetSel.iCountry = notHomeNetworkInfo->iCountryCode;

   328 	manNetSel.iNetwork = notHomeNetworkInfo->iNetworkId;

   329 	phone.SelectNetwork(reqSetNetworkStatus, ETrue, manNetSel );

   330 	

   331 	ASSERT_EQUALS( WaitForRequestWithTimeOut(reqSetNetworkStatus, ETimeLong ), KErrNone, 

   332 								_L("RMobilePhone::SelectNetwork timed out")	);

   333 	

   334 	//  Check this returns error != KErrorNone 

   335 	ASSERT_TRUE( KErrNone != reqSetNetworkStatus.Int(),	

   336 				_L("RMobilePhone::SelectNetwork on non home network succeeded - should fail"));

   337 

   338 	//  Check RMobilePhone::GetNetworkRegistrationStatus returns aStatus=ERegistrationDenied 

   339 	RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus;

   340 	iNetworkTestHelper.GetNetworkRegistrationStatusL(phone, registrationStatus);

   341 	ASSERT_EQUALS(registrationStatus, RMobilePhone::ERegistrationDenied, 

   342 						_L("RMobilePhone::GetNetworkRegistrationStatus did not return ERegistrationDenied"));

   343 

   344 	// ===  Register back on the home network ===

   345 	// Select network with RMobilePhone::SelectNetwork with 

   346 	// aIsManual=ETrue and aManualSelection.iCountry=aNetworkInfo.iCountryCode 

   347 	// of home network and aManualSelection.iNetwork=aNetworkInfo.iNetworkId of home network 

   348 	

   349 	manNetSel.iCountry = homeNetworkInfo.iCountryCode;

   350 	manNetSel.iNetwork = homeNetworkInfo.iNetworkId;

   351 	phone.SelectNetwork(reqSetNetworkStatus, ETrue, manNetSel );

   352 	

   353 	ASSERT_EQUALS( WaitForRequestWithTimeOut(reqSetNetworkStatus, ETimeLong ), KErrNone, 

   354 								_L("RMobilePhone::SelectNetwork timed out")	);

   355 	

   356 	//  Check this returns error != KErrorNone 

   357 	ASSERT_TRUE( KErrNone != reqSetNetworkStatus.Int(),	

   358 						_L("RMobilePhone::SelectNetwork on home network succeeded - should fail"));

   359 	

   360 	// ===  Get list of preferred networks and check it has not changed ===

   361 	// Use helper class for CRetrieveMobilePhonePreferredNetworks to retrieve a list of preferred networks 

   362 		

   363 	CRetrieveMobilePhonePreferredNetworksExec *checkNetListHelper = CRetrieveMobilePhonePreferredNetworksHelper::NewL(phone);

   364 	CleanupStack::PushL( checkNetListHelper );

   365 	

   366 	CMobilePhoneStoredNetworkList* checkPrefNetList = checkNetListHelper->DoGetList(err);

   367 	ASSERT_EQUALS(err, KErrNone, _L("CRetrieveMobilePhonePreferredNetworks::DoGetList failed to get the check list"));	

   368 	

   369 	// Check contents of each entry in the CMobilePhoneStoredNetworkList list retrieved is the same as the 

   370 	// first preferred network list.

   371 	

   372 	TInt prefListCount = prefNetList->Enumerate();

   373 	TInt checkListCount = checkPrefNetList->Enumerate();

   374 	

   375 	ASSERT_EQUALS( prefListCount, checkListCount, _L("Lists of preferred networks differ in size"));

   376 	

   377 	if(  prefListCount == checkListCount )

   378 		{

   379 		// Lists are the same size. We assume the order is the same too

   380 		for( TInt j=0; j < prefListCount; j++ )

   381 			{

   382 			const RMobilePhone::TMobilePreferredNetworkEntryV3 &prefInfo = prefNetList->GetEntryL(j);

   383 			const RMobilePhone::TMobilePreferredNetworkEntryV3 &checkInfo = checkPrefNetList->GetEntryL(j);

   384 			

   385 			ASSERT_EQUALS( prefInfo.iCountryCode, checkInfo.iCountryCode, _L("Phone entry country codes do not match"));

   386 			ASSERT_EQUALS( prefInfo.iNetworkId, checkInfo.iNetworkId, _L("Phone network ids do not match"));

   387 

   388 			}

   389 		}

   390 	*/	

   391 	// Repost the notification request

   392 	phone.NotifyNetworkSelectionSettingChange(notifyNetSelSettingChange, netSelNotifyPkg);

   393 

   394 	// ===  Put the phone into automatic network selection mode. ===

   395 	// Set network selection setting to manual with RMobilePhone::SetNetworkSelectionSetting 

   396 	// with aSetting.iMethod = ENetworkSelectionAutomatic 

   397 	netSelSetting.iMethod = RMobilePhone::ENetworkSelectionAutomatic;

   398 	phone.SetNetworkSelectionSetting( setNetSelSettingStatus, netSelSettingPkg );

   399 	

   400 	ASSERT_EQUALS(WaitForRequestWithTimeOut(setNetSelSettingStatus, ETimeLong), KErrNone, 

   401 					_L("RMobilePhone::SetNetworkSelectionSetting timed out") );

   402 					

   403 	ASSERT_EQUALS( setNetSelSettingStatus.Int(), KErrNone, 

   404 					_L("RMobilePhone::SetNetworkSelectionSetting returned error") );					

   405 

   406 	// ===  Verify automatic selection mode has been set and notification received ===

   407 

   408 	// Check RMobilePhone::NotifyNetworkSelectionSettingChange completes with aSetting.iMethod = ENetworkSelectionAutomatic

   409 	iNetworkTestHelper.WaitForMobilePhoneNotifyNetworkSelectionSettingChange(phone, 

   410 															notifyNetSelSettingChange, netSelNotify, 

   411 															RMobilePhone::ENetworkSelectionAutomatic,

   412 															KErrNone);	

   413 

   414 	// Check RMobilePhone::GetNetworkSelectionSetting returns aSetting.iMethod = ENetworkSelectionAutomatic

   415 	ASSERT_EQUALS( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

   416 					_L("RMobilePhone::GetNetworkSelectionSetting returned an error") );

   417 	ASSERT_EQUALS( netSelSetting.iMethod, RMobilePhone::ENetworkSelectionAutomatic, 

   418 					_L("RMobilePhone::GetNetworkSelectionSetting did not return ENetworkSelectionAutomatic") );

   419 	

   420 	//

   421 	// TEST END

   422 	//

   423 

   424     StartCleanup();

   425 	

   426 	// netListHelper

   427 	// setNetSelSettingStatus

   428 	// notifyNetSelSettingChange

   429     // getHomeNetworkStatus

   430 	CleanupStack::PopAndDestroy(4,&getHomeNetworkStatus);

   431 	

   432 	return TestStepResult();

   433 	}

   434 	

   435 

   436 TPtrC CCTSYIntegrationTestNetworkControl0001::GetTestStepName()

   437 /**

   438  * @return The test step name.

   439  */

   440 	{

   441 	return _L("CCTSYIntegrationTestNetworkControl0001");

   442 	}

   443 

   444 

   445 

   446 CCTSYIntegrationTestNetworkControl0002::CCTSYIntegrationTestNetworkControl0002(CEtelSessionMgr& aEtelSessionMgr)

   447 	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

   448 /**

   449  * Constructor.

   450  */

   451 	{

   452 	SetTestStepName(CCTSYIntegrationTestNetworkControl0002::GetTestStepName());

   453 	}

   454 

   455 CCTSYIntegrationTestNetworkControl0002::~CCTSYIntegrationTestNetworkControl0002()

   456 /**

   457  * Destructor.

   458  */

   459 	{

   460 	}

   461 

   462 TVerdict CCTSYIntegrationTestNetworkControl0002::doTestStepL()

   463 /**

   464  * @SYMTestCaseID BA-CTSY-INT-NTWC-0002

   465  * @SYMFssID BA/CTSY/NTWC-0002

   466  * @SYMTestCaseDesc Basic cell selection

   467  * @SYMTestPriority High

   468  * @SYMTestActions RMobilePhone::GetCurrentNetwork, RMobilePhone::GetLastUsedAccessTechnology, RMobilePhone::GetNetworkRegistrationStatus, RMobilePhone::GetServiceProviderName, RMobilePhone::GetCurrentNetworkName

   469  * @SYMTestExpectedResults Pass - Phone camps on a cell

   470  * @SYMTestType CIT

   471  * @SYMTestCaseDependencies live/automatic

   472  *

   473  * Reason for test: Verify phone has camped on a cell with an expected network information - name, mode, type, cellid, location area

   474  *

   475  * @return - TVerdict code

   476  */

   477 	{

   478 	//

   479 	// SET UP

   480 	//

   481 

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

   483 	

   484 	iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone);

   485 	

   486 	// Ensure that RMobilePhone::GetNetworkCaps returns caps in set of KCapsGetRegistrationStatus | KCapsGetCurrentMode | KCapsGetCurrentNetwork | KCapsGetHomeNetwork 

   487 	TUint32 networkCaps=0;

   488 	CHECK_EQUALS_L(mobilePhone.GetNetworkCaps(networkCaps), KErrNone,

   489 				   _L("RMobilePhone::GetNetworkCaps returned with an error"));

   490 	TUint32 expectedCaps= RMobilePhone::KCapsGetRegistrationStatus | RMobilePhone::KCapsGetCurrentMode 

   491 						  | RMobilePhone::KCapsGetCurrentNetwork | RMobilePhone::KCapsGetHomeNetwork;

   492 	CHECK_BITS_SET_L(networkCaps, expectedCaps, KNoUnwantedBits,

   493 					 _L("RMobilePhone::GetNetworkCaps returned with wrong caps"));

   494 

   495 	//

   496 	// SET UP END

   497 	//

   498 	

   499 	StartTest();

   500 	

   501 	//

   502 	// TEST START

   503 	//

   504 	

   505 	// ===  Get mode ===

   506 

   507 	// Check RMobilePhone::GetCurrentMode returns aNetworkMode=ENetworkModeGsm or ENetworkModeWcdma

   508 	RMobilePhone::TMobilePhoneNetworkMode mode;

   509 	ASSERT_EQUALS(mobilePhone.GetCurrentMode(mode), KErrNone, _L("RMobilePhone::GetCurrentMode returned with an error"));

   510 	

   511 	ASSERT_TRUE((mode == RMobilePhone::ENetworkModeGsm) || (mode == RMobilePhone::ENetworkModeWcdma),

   512 				_L("RMobilePhone::GetCurrentMode did not return ENetworkModeGsm or ENetworkModeWcdma as expected"));

   513 	

   514 	// ===  Get current network ===

   515 

   516 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iCountryCode with length > 0

   517 	RMobilePhone::TMobilePhoneNetworkInfoV5 netInfo;

   518     RMobilePhone::TMobilePhoneLocationAreaV1 location;

   519     RMobilePhone::TMobilePhoneNetworkInfoV5Pckg netInfoPckg(netInfo);

   520     TExtEtelRequestStatus getCurrentNetworkStatus(mobilePhone, EMobilePhoneGetCurrentNetwork);	

   521 	CleanupStack::PushL(getCurrentNetworkStatus);

   522 	mobilePhone.GetCurrentNetwork(getCurrentNetworkStatus, netInfoPckg, location);

   523 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCurrentNetworkStatus, ETimeMedium),KErrNone, 

   524 				  _L("RMobilePhone::GetCurrentNetwork timed out"));

   525 	ASSERT_EQUALS(getCurrentNetworkStatus.Int(), KErrNone, _L("RMobilePhone::GetCurrentNetwork returned with an error"));

   526 	ASSERT_TRUE(netInfo.iCountryCode.Length()>0 , _L("RMobilePhone::GetCurrentNetwork returned with blank Country Code"));			

   527 	

   528 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iLongName with length > 0

   529 	ASSERT_TRUE(netInfo.iLongName.Length()>0 , _L("RMobilePhone::GetCurrentNetwork returned with blank Long Name"));			

   530 	

   531 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iMode=ENetworkModeGsm or ENetworkModeWcdma

   532 	ASSERT_TRUE((netInfo.iMode == RMobilePhone::ENetworkModeGsm) || (netInfo.iMode == RMobilePhone::ENetworkModeWcdma) , _L("RMobilePhone::GetCurrentNetwork did not return ENetworkModeGsm Mode or ENetworkModeWcdma Mode"));		

   533 		

   534 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iNetworkId with length > 0

   535 	ASSERT_TRUE(netInfo.iNetworkId.Length()>0 , _L("RMobilePhone::GetCurrentNetwork returned with blank Network Id"));			

   536 	

   537 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iShortName with length > 0

   538 	ASSERT_TRUE(netInfo.iShortName.Length()>0 , _L("RMobilePhone::GetCurrentNetwork returned with blank Short Name"));			

   539 	

   540 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iStatus=ENetworkStatusCurrent

   541 	ASSERT_EQUALS(netInfo.iStatus,RMobilePhone::ENetworkStatusCurrent , _L("RMobilePhone::GetCurrentNetwork did not return ENetworkStatusCurrent status as expected "));			

   542 

   543 	// Check RMobilePhone::GetLastUsedAccessTechnology returns aAccessTech=ENetworkAccessUnknown or ENetworkAccessGsm or ENetworkAccessGsmCompact or ENetworkAccessUtran

   544 	RMobilePhone::TMobilePhoneNetworkAccess accessTech;

   545 	TExtEtelRequestStatus getLastUsedAccessTechnologyStatus(mobilePhone, EMobilePhoneGetLastUsedAccessTechnology);	

   546 	CleanupStack::PushL(getLastUsedAccessTechnologyStatus);

   547 	mobilePhone.GetLastUsedAccessTechnology(getLastUsedAccessTechnologyStatus,accessTech);

   548 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getLastUsedAccessTechnologyStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetLastUsedAccessTechnology timed out"));

   549 	ASSERT_EQUALS(getLastUsedAccessTechnologyStatus.Int(), KErrNotSupported, _L("RMobilePhone::GetLastUsedAccessTechnology returned with an error"));

   550 

   551 	// Check RMobilePhone::GetNetworkRegistrationStatus returns aStatus=ERegisteredOnHomeNetwork

   552 	RMobilePhone::TMobilePhoneRegistrationStatus  status;

   553 	ASSERT_EQUALS(iNetworkTestHelper.GetNetworkRegistrationStatusL( mobilePhone, status), KErrNone, _L("RMobilePhone::GetNetworkRegistrationStatus returned with an error"));

   554 	ASSERT_EQUALS(status, RMobilePhone::ERegisteredOnHomeNetwork,

   555 	              _L("RMobilePhone::GetNetworkRegistrationStatus did not return the expected ERegisteredOnHomeNetwork Status"));

   556 	

   557 	// ===  Get service provider name ===

   558 

   559 	// Check RMobilePhone::GetServiceProviderName with a TMobilePhoneServiceProviderNameV2 parameter returns aName.iPLMNField with length > 0

   560 	RMobilePhone::TMobilePhoneServiceProviderNameV2 providerName;

   561     RMobilePhone::TMobilePhoneServiceProviderNameV2Pckg providerNamePckg(providerName);

   562     TExtEtelRequestStatus getServiceProviderNameStatus(mobilePhone, EMobilePhoneGetServiceProviderName);	

   563 	CleanupStack::PushL(getServiceProviderNameStatus);

   564     mobilePhone.GetServiceProviderName(getServiceProviderNameStatus, providerNamePckg);

   565 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getServiceProviderNameStatus, ETimeMedium),KErrNone, 

   566 	              _L("RMobilePhone::GetServiceProviderName timed out"));

   567 	ASSERT_EQUALS(getServiceProviderNameStatus.Int(), KErrGsm0707NotFound, 

   568 	              _L("RMobilePhone::GetServiceProviderName returned with an error"));

   569 	

   570 	// $CTSYProblem

   571 	// For RMobilePhone::GetServiceProviderName, LTSY is returning KErrGsm0707NotFound

   572 	// CTSY is correctly propagating the error back to the client.

   573 	// If the LTSY is altered to retrieve the provider name successfully, the following

   574 	// test code can be used and KErrNone can be expected from this API.

   575 	

   576 /*	// Check RMobilePhone::GetServiceProviderName with a TMobilePhoneServiceProviderNameV2 parameter returns aName.iDisplayReq with length > 0

   577 	ASSERT_TRUE(providerName.iDisplayReq !=0, _L("RMobilePhone::GetServiceProviderName returned 0 RMobilePhone::TMobilePhoneServiceProviderNameV2.iDisplayReq"));

   578 	

   579 	// Check RMobilePhone::GetServiceProviderName with a TMobilePhoneServiceProviderNameV2 parameter returns aName.iPLMNField with length > 0

   580 	ASSERT_TRUE(providerName.iPLMNField.Length()>0 , _L("RMobilePhone::GetServiceProviderName returned with blank PLMNField"));			

   581 	

   582 	// Check RMobilePhone::GetServiceProviderName with a TMobilePhoneServiceProviderNameV2 parameter returns aName.iSPName with length > 0

   583 	ASSERT_TRUE(providerName.iSPName.Length()>0 , _L("RMobilePhone::GetServiceProviderName returned with blank SPName"));			

   584 */

   585 	

   586 	// Check RMobilePhone::GetCurrentNetworkName with a TMobilePhoneNetworkNameV3 returns aNetworkName.iLongName with length > 0

   587 	RMobilePhone::TMobilePhoneNetworkNameV3 networkname;

   588 	RMobilePhone::TMobilePhoneNetworkNameV3Pckg networknamePckg(networkname);

   589     RMobilePhone::TMobilePhoneOPlmnV3 locInfo;

   590  	RMobilePhone::TMobilePhoneOPlmnV3Pckg locInfoPckg(locInfo);

   591     TExtEtelRequestStatus getCurrentNetworkNameStatus(mobilePhone, EMobilePhoneGetNetworkName);	

   592 	CleanupStack::PushL(getCurrentNetworkNameStatus);

   593 	mobilePhone.GetCurrentNetworkName(getCurrentNetworkNameStatus, networknamePckg, locInfoPckg);

   594 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCurrentNetworkNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetCurrentNetworkName timed out"));

   595 	ASSERT_EQUALS(getCurrentNetworkNameStatus.Int(), KErrNone, _L("RMobilePhone::GetCurrentNetworkName returned with an error"));

   596 	ASSERT_TRUE(networkname.iLongName.Length()>0 , _L("RMobilePhone::GetCurrentNetworkName returned with blank Long Name"));			

   597 

   598 	// Check RMobilePhone::GetCurrentNetworkName with a TMobilePhoneNetworkNameV3 returns aNetworkName.iShortName with length > 0

   599 	ASSERT_TRUE(networkname.iShortName.Length()>0 , _L("RMobilePhone::GetServiceProviderName returned with blank Short Name"));		

   600 		

   601 	// Check RMobilePhone::GetCurrentNetworkName with a TMobilePhoneOPlmnV3 returns aLocInfo.iCountryCode with length > 0

   602 	ASSERT_TRUE(locInfo.iCountryCode.Length()>0 , _L("RMobilePhone::GetServiceProviderName returned with blank Country Code"));			

   603 	

   604 	// Check RMobilePhone::GetCurrentNetworkName with a TMobilePhoneOPlmnV3 returns aLocInfo.iNetworkId with length > 0

   605 	ASSERT_TRUE(locInfo.iNetworkId.Length()>0 , _L("RMobilePhone::GetServiceProviderName returned with blank Network Id"));			

   606 	

   607 	//

   608 	// TEST END

   609 	//

   610 

   611     StartCleanup();

   612     // Pop

   613     // getCurrentNetworkStatus

   614     // getLastUsedAccessTechnologyStatus

   615     // getServiceProviderNameStatus

   616     // getCurrentNetworkNameStatus

   617 	

   618 	CleanupStack::PopAndDestroy(4, &getCurrentNetworkStatus);

   619 	

   620 	return TestStepResult();

   621 	}

   622 

   623 TPtrC CCTSYIntegrationTestNetworkControl0002::GetTestStepName()

   624 /**

   625  * @return The test step name.

   626  */

   627 	{

   628 	return _L("CCTSYIntegrationTestNetworkControl0002");

   629 	}

   630 

   631 

   632 

   633 CCTSYIntegrationTestNetworkControl0003::CCTSYIntegrationTestNetworkControl0003(CEtelSessionMgr& aEtelSessionMgr)

   634 	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

   635 /**

   636  * Constructor.

   637  */

   638 	{

   639 	SetTestStepName(CCTSYIntegrationTestNetworkControl0003::GetTestStepName());

   640 	}

   641 

   642 CCTSYIntegrationTestNetworkControl0003::~CCTSYIntegrationTestNetworkControl0003()

   643 /**

   644  * Destructor.

   645  */

   646 	{

   647 	}

   648 

   649 TVerdict CCTSYIntegrationTestNetworkControl0003::doTestStepL()

   650 /**

   651  * @SYMTestCaseID BA-CTSY-INT-NTWC-0003

   652  * @SYMFssID BA/CTSY/NTWC-0003

   653  * @SYMTestCaseDesc Cell reselection from "no service" state

   654  * @SYMTestPriority High

   655  * @SYMTestActions RMobilePhone::GetCurrentNetwork, RMobilePhone::NotifyNetworkRegistrationStatusChange, RMobilePhone::GetNetworkRegistrationStatus, RMobilePhone::NotifyCurrentNetworkChange, RMobilePhone::NotifyModeChange

   656  * @SYMTestExpectedResults Pass - Phone reselects a cell.

   657  * @SYMTestType CIT

   658  * @SYMTestCaseDependencies live/manual

   659  *

   660  * Reason for test: Verify cell is reselected and network information is correct.

   661  *

   662  * @return - TVerdict code

   663  */

   664 	{

   665 

   666 	//

   667 	// SET UP

   668 	//

   669     

   670     RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   671     CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   672 	

   673     // Phone is in a blackspot, with no coverage. 

   674 	DisplayUserInteractionPromptL(_L("Please be sure that phone is in a blackspot, with no coverage"), ETimeLong);

   675 

   676 	// Ensure that RMobilePhone::GetNetworkCaps returns caps in set of KCapsGetRegistrationStatus | KCapsGetCurrentMode | KCapsGetCurrentNetwork | KCapsNotifyRegistrationStatus | KCapsNotifyMode | KCapsNotifyCurrentNetwork 

   677 	TUint32 networkCaps = 0;

   678 	TUint32 expectedCaps = RMobilePhone::KCapsGetRegistrationStatus | RMobilePhone::KCapsGetCurrentMode | RMobilePhone::KCapsGetCurrentNetwork | RMobilePhone::KCapsNotifyRegistrationStatus | RMobilePhone::KCapsNotifyMode | RMobilePhone::KCapsNotifyCurrentNetwork;

   679 	CHECK_EQUALS_L(phone.GetNetworkCaps(networkCaps), KErrNone, _L("RMobilePhone::GetNetworkCaps returned with an error"));

   680 	CHECK_BITS_SET_L(networkCaps, expectedCaps, KNoUnwantedBits, _L("RMobilePhone::GetNetworkCaps returned with wrong caps"));

   681 

   682 

   683 	//

   684 	// SET UP END

   685 	//

   686 	

   687 	StartTest();

   688 	

   689 	//

   690 	// TEST START

   691 	//

   692 	ERR_PRINTF2(_L("<font color=Orange>$CTSYProblem: defect id = %d</font>"), 10075);

   693 	User::Leave(KErrNone);	

   694 	

   695 	

   696 	// Check RMobilePhone::GetNetworkRegistrationStatus returns ENotRegisteredNoService or ENotRegisteredSearching

   697     RMobilePhone::TMobilePhoneRegistrationStatus status;

   698 	ASSERT_EQUALS(iNetworkTestHelper.GetNetworkRegistrationStatusL(phone, status), KErrNone, _L("RMobilePhone::GetNetworkRegistrationStatus returned with an error"));

   699 	ASSERT_TRUE(status != RMobilePhone::ENotRegisteredSearching || status != RMobilePhone::ENotRegisteredNoService, 

   700 	            _L("RMobilePhone::GetNetworkRegistrationStatus did not return the expected ENotRegisteredSearching or ENotRegisteredNoServiceStatus"));

   701 	

   702 	TExtEtelRequestStatus reqNetworkRegStatusChange(phone, EMobilePhoneNotifyNetworkRegistrationStatusChange);

   703     CleanupStack::PushL(reqNetworkRegStatusChange);

   704     // Call notify for networkregistrationchange

   705     RMobilePhone::TMobilePhoneRegistrationStatus networkRegStatus;

   706     phone.NotifyNetworkRegistrationStatusChange(reqNetworkRegStatusChange, networkRegStatus);

   707     

   708    	TExtEtelRequestStatus reqNotifyCurrentNetChangeStatus(phone, EMobilePhoneNotifyCurrentNetworkChange);

   709 	CleanupStack::PushL(reqNotifyCurrentNetChangeStatus);

   710 	RMobilePhone::TMobilePhoneNetworkInfoV5 netInfo;

   711 	RMobilePhone::TMobilePhoneLocationAreaV1 locationArea;

   712 	TPckg<RMobilePhone::TMobilePhoneNetworkInfoV5> netInfoPkg(netInfo);

   713 	// Call notify for networkchange

   714 	phone.NotifyCurrentNetworkChange(reqNotifyCurrentNetChangeStatus, netInfoPkg, locationArea );

   715 	

   716 	TExtEtelRequestStatus reqNotifyModeChangeStatus(phone, EMobilePhoneNotifyModeChange);

   717 	CleanupStack::PushL(reqNotifyModeChangeStatus);

   718 	RMobilePhone::TMobilePhoneNetworkMode mobNetworkMode;

   719 	// Call notify for NotifyModeChange

   720 	phone.NotifyModeChange(reqNotifyModeChangeStatus, mobNetworkMode);

   721 	

   722 	// Move phone to an area with coverage 

   723 	DisplayUserInteractionPromptL(_L("Move phone to an area with coverage"), ETimeLong);

   724 

   725 	// ===  Check cell is reselected and network information is correct ===

   726 

   727 	// Check RMobilePhone::NotifyNetworkRegistrationStatusChange completes with aStatus=ERegisteredOnHomeNetwork

   728 	RMobilePhone::TMobilePhoneRegistrationStatus expectedStatus = RMobilePhone::ERegisteredOnHomeNetwork;

   729 	const TInt wantedStatus = KErrNone;

   730 	iNetworkTestHelper.WaitForMobilePhoneNotifyNetworkRegistrationStatusChange(phone, reqNetworkRegStatusChange, networkRegStatus, expectedStatus, wantedStatus);

   731 		

   732 	// Check RMobilePhone::GetNetworkRegistrationStatus returns ERegisteredOnHomeNetwork

   733 	ASSERT_EQUALS(iNetworkTestHelper.GetNetworkRegistrationStatusL(phone, status), KErrNone, _L("RMobilePhone::GetNetworkRegistrationStatus returned with an error"));

   734 	ASSERT_EQUALS(status, RMobilePhone::ERegisteredOnHomeNetwork, _L("RMobilePhone::GetNetworkRegistrationStatus did not return the expected ENotRegisteredSearching or ENotRegisteredNoServiceStatus"));

   735 

   736 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iCountryCode with length > 0

   737 	ASSERT_EQUALS(WaitForRequestWithTimeOut(reqNotifyCurrentNetChangeStatus, ETimeMedium), KErrNone, _L("RMobilePhone::NotifyCurrentNetworkChange timed out"));

   738 	ASSERT_EQUALS(reqNotifyCurrentNetChangeStatus.Int(), KErrNone, _L("RMobilePhone::NotifyCurrentNetworkChange returned error"));

   739 	

   740 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iDisplayTag with length > 0

   741 	ASSERT_TRUE(netInfo.iDisplayTag.Length() > 0, _L("RMobilePhone::NotifyCurrentNetworkChange returns invalid iDisplayTag"));

   742 	

   743 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iLongName with length > 0

   744 	ASSERT_TRUE(netInfo.iLongName.Length() > 0, _L("RMobilePhone::NotifyCurrentNetworkChange returns invalid iLongName"));

   745 	

   746 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iMode=ENetworkModeGsm

   747 	ASSERT_EQUALS(netInfo.iMode, RMobilePhone::ENetworkModeGsm, _L("RMobilePhone::NotifyCurrentNetworkChange iMode did not return ENetworkModeGsm as expected"));

   748 	

   749 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iNetworkId with length > 0

   750 	ASSERT_TRUE(netInfo.iNetworkId.Length() > 0, _L("RMobilePhone::NotifyCurrentNetworkChange returns invalid iNetworkId"));

   751 	

   752 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iShortName with length > 0

   753 	ASSERT_TRUE(netInfo.iShortName.Length() > 0, _L("RMobilePhone::NotifyCurrentNetworkChange returns invalid iShortName"));

   754 	

   755 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iStatus=ENetworkStatusCurrent

   756 	ASSERT_EQUALS(netInfo.iStatus, RMobilePhone::ENetworkStatusCurrent, _L("RMobilePhone::NotifyCurrentNetworkChange iStatus did not return ENetworkStatusCurrent as expected"));

   757 	

   758 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aArea.iCellId > 0

   759 	ASSERT_TRUE(locationArea.iCellId > 0, _L("RMobilePhone::NotifyCurrentNetworkChange returns invalid iCellId"));

   760 	

   761 	// Check RMobilePhone::NotifyCurrentNetworkChange with parameter type TMobilePhoneNetworkInfoV5 returns aArea.iLocationAreaCode > 0

   762 	ASSERT_TRUE(locationArea.iLocationAreaCode > 0, _L("RMobilePhone::NotifyCurrentNetworkChange returns invalid iLocationAreaCode"));

   763 

   764 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iCountryCode with length > 0

   765 	RMobilePhone::TMobilePhoneNetworkInfoV5 currentNetworkInfo;

   766     RMobilePhone::TMobilePhoneLocationAreaV1 currentNetworkAreaLocation;

   767     RMobilePhone::TMobilePhoneNetworkInfoV5Pckg currentNetworkInfoPckg(currentNetworkInfo);

   768     TExtEtelRequestStatus getCurrentNetworkStatus(phone, EMobilePhoneGetCurrentNetwork);	

   769 	CleanupStack::PushL(getCurrentNetworkStatus);

   770 	phone.GetCurrentNetwork(getCurrentNetworkStatus, currentNetworkInfoPckg, currentNetworkAreaLocation);

   771     ASSERT_EQUALS(WaitForRequestWithTimeOut(getCurrentNetworkStatus, ETimeMedium), KErrNone, _L("RMobilePhone::GetCurrentNetwork timed out"));

   772 	ASSERT_EQUALS(getCurrentNetworkStatus.Int(), KErrNone, _L("RMobilePhone::GetCurrentNetwork returned returned error"));

   773 

   774 	

   775 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iDisplayTag with length > 0

   776 	ASSERT_TRUE(currentNetworkInfo.iDisplayTag.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iDisplayTag"));

   777 	

   778 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iLongName with length > 0

   779 	ASSERT_TRUE(currentNetworkInfo.iLongName.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iLongName"));

   780 	

   781 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iMode=ENetworkModeGsm

   782 	ASSERT_EQUALS(currentNetworkInfo.iMode, RMobilePhone::ENetworkModeGsm, _L("RMobilePhone::GetCurrentNetwork iMode did not return ENetworkModeGsm as expected"));

   783 	

   784 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iNetworkId with length > 0

   785 	ASSERT_TRUE(currentNetworkInfo.iNetworkId.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iNetworkId"));

   786 	

   787 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iShortName with length > 0

   788 	ASSERT_TRUE(currentNetworkInfo.iShortName.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iShortName"));

   789 	

   790 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iStatus=ENetworkStatusCurrent

   791 	ASSERT_EQUALS(currentNetworkInfo.iStatus, RMobilePhone::ENetworkStatusCurrent, _L("RMobilePhone::GetCurrentNetwork iStatus did not return ENetworkStatusCurrent as expected"));

   792 	

   793 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aArea.iCellId > 0

   794     ASSERT_TRUE(currentNetworkAreaLocation.iCellId > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iCellId"));

   795 	

   796 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aArea.iLocationAreaCode > 0

   797 	ASSERT_TRUE(currentNetworkAreaLocation.iLocationAreaCode > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iLocationAreaCode"));

   798 

   799 	// Check RMobilePhone::NotifyModeChange completes with aNetworkMode=ENetworkModeGsm

   800 	RMobilePhone::TMobilePhoneNetworkMode expectedMobNetMode = RMobilePhone::ENetworkModeGsm;

   801 	iNetworkTestHelper.WaitForMobilePhoneNotifyModeChange(phone, reqNotifyModeChangeStatus, mobNetworkMode, expectedMobNetMode, wantedStatus);

   802 

   803 	// Check RMobilePhone::GetCurrentMode completes with aNetworkMode=ENetworkModeGsm

   804 	RMobilePhone::TMobilePhoneNetworkMode currentMobNetMode;

   805 	phone.GetCurrentMode(currentMobNetMode);

   806 	ASSERT_EQUALS(currentMobNetMode, RMobilePhone::ENetworkModeGsm, _L("RMobilePhone::GetCurrentMode did not return ENetworkModeGsm as expected"));

   807 	

   808 	//

   809 	// TEST END

   810 	//

   811 

   812     StartCleanup();

   813 	

   814 	// Pop

   815     // reqNetworkRegStatusChange

   816     // reqNotifyCurrentNetChangeStatus

   817     // getCurrentNetworkStatus

   818     // reqNotifyModeChangeStatus

   819 	CleanupStack::PopAndDestroy(4, &reqNetworkRegStatusChange);

   820 	

   821 	return TestStepResult();

   822 	}

   823 

   824 TPtrC CCTSYIntegrationTestNetworkControl0003::GetTestStepName()

   825 /**

   826  * @return The test step name.

   827  */

   828 	{

   829 	return _L("CCTSYIntegrationTestNetworkControl0003");

   830 	}

   831 

   832 

   833 

   834 CCTSYIntegrationTestNetworkControl0004::CCTSYIntegrationTestNetworkControl0004(CEtelSessionMgr& aEtelSessionMgr)

   835 	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

   836 /**

   837  * Constructor.

   838  */

   839 	{

   840 	SetTestStepName(CCTSYIntegrationTestNetworkControl0004::GetTestStepName());

   841 	}

   842 

   843 CCTSYIntegrationTestNetworkControl0004::~CCTSYIntegrationTestNetworkControl0004()

   844 /**

   845  * Destructor.

   846  */

   847 	{

   848 	}

   849 

   850 TVerdict CCTSYIntegrationTestNetworkControl0004::doTestStepL()

   851 /**

   852  * @SYMTestCaseID BA-CTSY-INT-NTWC-0004

   853  * @SYMFssID BA/CTSY/NTWC-0004

   854  * @SYMTestCaseDesc Emergency camping

   855  * @SYMTestPriority High

   856  * @SYMTestActions 

   857  * @SYMTestExpectedResults Pass - Phone registers for emergency calls only

   858  * @SYMTestType CIT

   859  * @SYMTestCaseDependencies live/manual

   860  *

   861  * Reason for test: Verify registration status is for emergency calls only.

   862  *

   863  * @return - TVerdict code

   864  */

   865 	{

   866 

   867 	//

   868 	// SET UP

   869 	//

   870 

   871 	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   872 

   873 	// Log a message to indicate that this test is run without a SIM in the phone

   874 	DisplayUserInteractionPromptL(_L("Remove SIM card before running this test"), ETimeMedium);

   875 		

   876 	//

   877 	// SET UP END

   878 	//

   879 	

   880 	StartTest();

   881 	

   882 	//

   883 	// TEST START

   884 	//

   885 	

   886 	// Ensure that RMobilePhone::GetNetworkCaps returns caps in set of KCapsGetRegistrationStatus 

   887 	TUint32 networkCaps = 0;

   888 	TUint32 expectedCaps = RMobilePhone::KCapsGetRegistrationStatus;

   889 	ASSERT_EQUALS(phone.GetNetworkCaps(networkCaps), KErrNone, _L("RMobilePhone::GetNetworkCaps returned with an error"));

   890 	ASSERT_BITS_SET(networkCaps, expectedCaps, KNoUnwantedBits, _L("RMobilePhone::GetNetworkCaps returned with wrong caps"));

   891 

   892 	// ===  Check that registration status is for emergency calls only. ===

   893 

   894 	// Check RMobilePhone::GetNetworkRegistrationStatus returns ENotRegisteredSearching

   895 	RMobilePhone::TMobilePhoneRegistrationStatus  status;

   896 	ASSERT_EQUALS(iNetworkTestHelper.GetNetworkRegistrationStatusL(phone, status), KErrNone, _L("RMobilePhone::GetNetworkRegistrationStatus returned with an error"));

   897 	// $CTSYProblem LTSY does not send correct notification. This wast tested using different timeout's but

   898     // ENotRegisteredEmergencyOnly notification did not arrive as expected.

   899     // Test was modified to accept ENotRegisteredSearching state, because this is the

   900     // one which returned from LTSY. From logs we could see that this was the only state which was notified to CTSY.

   901 	ASSERT_EQUALS(status, RMobilePhone::ENotRegisteredSearching, _L("RMobilePhone::GetNetworkRegistrationStatus did not return the expected ENotRegisteredSearching Status"));

   902 

   903 	//

   904 	// TEST END

   905 	//

   906 

   907     StartCleanup();

   908 	

   909 	return TestStepResult();

   910 	}

   911 

   912 TPtrC CCTSYIntegrationTestNetworkControl0004::GetTestStepName()

   913 /**

   914  * @return The test step name.

   915  */

   916 	{

   917 	return _L("CCTSYIntegrationTestNetworkControl0004");

   918 	}

   919 

   920 

   921 

   922 CCTSYIntegrationTestNetworkControl0005::CCTSYIntegrationTestNetworkControl0005(CEtelSessionMgr& aEtelSessionMgr)

   923 	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

   924 /**

   925  * Constructor.

   926  */

   927 	{

   928 	SetTestStepName(CCTSYIntegrationTestNetworkControl0005::GetTestStepName());

   929 	}

   930 

   931 CCTSYIntegrationTestNetworkControl0005::~CCTSYIntegrationTestNetworkControl0005()

   932 /**

   933  * Destructor.

   934  */

   935 	{

   936 	}

   937 

   938 TVerdict CCTSYIntegrationTestNetworkControl0005::doTestStepL()

   939 /**

   940  * @SYMTestCaseID BA-CTSY-INT-NTWC-0005

   941  * @SYMFssID BA/CTSY/NTWC-0005

   942  * @SYMTestCaseDesc Automatic cell selection

   943  * @SYMTestPriority High

   944  * @SYMTestActions RMobilePhone::GetCurrentNetwork, RMobilePhone::GetHomeNetwork, RMobilePhone::GetNetworkSelectionSetting, RMobilePhone::GetHomeNetworkSearchPeriod

   945  * @SYMTestExpectedResults Pass - Home, current and preferred network information are correct.

   946  * @SYMTestType CIT

   947  * @SYMTestCaseDependencies live/automatic

   948  *

   949  * Reason for test: Verify home network info., current network info. correct and home network is in the preferred network list.

   950  *

   951  * @return - TVerdict code

   952  */

   953 	{

   954 

   955 	//

   956 	// SET UP

   957 	//

   958 	

   959 	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   960 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   961 	

   962 	// Ensure that RMobilePhone::GetNetworkCaps returns caps in set of KCapsGetHomeNetwork | KCapsGetCurrentNetwork 

   963 	TUint32 caps;

   964 	CHECK_EQUALS_L(phone.GetNetworkCaps(caps), KErrNone, _L("RMobilePhone::GetNetworkCaps returned an error"));

   965 	TUint32 wantedCaps = RMobilePhone::KCapsGetHomeNetwork | RMobilePhone::KCapsGetCurrentNetwork;

   966 	CHECK_BITS_SET_L(caps, wantedCaps, KNoUnwantedBits, _L("RMobilePhone::GetNetworkCaps returned wrong caps"));

   967 

   968 	//

   969 	// SET UP END

   970 	//

   971 	

   972 	StartTest();

   973 	

   974 	//

   975 	// TEST START

   976 	//

   977 	

   978 	RMobilePhone::TMobilePhoneNetworkSelectionV1 netSelSetting;

   979 	RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg netSelSettingPckg(netSelSetting);

   980 	

   981 	// Check RMobilePhone::GetNetworkSelectionSetting returns aSetting.iMethod = ENetworkSelectionAutomatic

   982 	ASSERT_EQUALS( phone.GetNetworkSelectionSetting( netSelSettingPckg ), KErrNone, _L("RMobilePhone::GetNetworkSelectionSetting returned an error") );

   983 	ASSERT_EQUALS( netSelSetting.iMethod, RMobilePhone::ENetworkSelectionAutomatic, _L("RMobilePhone::GetNetworkSelectionSetting did not return ENetworkSelectionAutomatic") );

   984 	

   985 	// $CTSYProblem

   986 	// CTSY does not support RMobilePhone::GetHomeNetworkSearchPeriod

   987 	// GetHomeNetworkSearchPeriod responses directly with KErrNotSupported

   988     

   989 	// Check RMobilePhone::GetHomeNetworkSearchPeriod returns aSearchIntv >= 0

   990 	TExtEtelRequestStatus searchPeriodReqStatus(phone, EMobilePhoneGetHomeNetworkSearchPeriod);

   991 	CleanupStack::PushL(searchPeriodReqStatus);

   992 	TInt searchIntv;

   993 	phone.GetHomeNetworkSearchPeriod(searchPeriodReqStatus, searchIntv);

   994 	ASSERT_EQUALS(WaitForRequestWithTimeOut(searchPeriodReqStatus, ETimeLong), KErrNone, _L("RMobilePhone::GetHomeNetworkSearchPeriod timed out"));

   995 	ASSERT_EQUALS(searchPeriodReqStatus.Int(), KErrNotSupported, _L("RMobilePhone::GetHomeNetworkSearchPeriod returned an error"));

   996 

   997 	// ===  Get the home network information. ===

   998 	RMobilePhone::TMobilePhoneNetworkInfoV5 homeNWInfo;

   999     RMobilePhone::TMobilePhoneNetworkInfoV5Pckg homeNWInfoPckg(homeNWInfo);

  1000 	TExtEtelRequestStatus getHomeNetworkStatus(phone, EMobilePhoneGetHomeNetwork);

  1001 	CleanupStack::PushL(getHomeNetworkStatus);

  1002 	phone.GetHomeNetwork(getHomeNetworkStatus, homeNWInfoPckg);

  1003 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getHomeNetworkStatus, ETimeLong), KErrNone, _L("RMobilePhone::GetHomeNetwork timed out"));

  1004 	ASSERT_EQUALS(getHomeNetworkStatus.Int(), KErrNone, _L("RMobilePhone::GetHomeNetwork returned an error"));

  1005 

  1006 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iCountryCode with length > 0

  1007 	ASSERT_TRUE(homeNWInfo.iCountryCode.Length() > 0, _L("RMobilePhone::GetHomeNetwork returns invalid CountryCode Tag"));

  1008 	

  1009 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iDisplayTag with length > 0

  1010 	ASSERT_TRUE(homeNWInfo.iDisplayTag.Length() > 0, _L("RMobilePhone::GetHomeNetwork returns invalid iDisplayTag"));

  1011 	

  1012 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iLongName with length > 0

  1013 	ASSERT_TRUE(homeNWInfo.iLongName.Length() > 0, _L("RMobilePhone::GetHomeNetwork returns invalid iLongName"));

  1014 	

  1015 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iMode=ENetworkModeGsm

  1016 	ASSERT_EQUALS(homeNWInfo.iMode, RMobilePhone::ENetworkModeGsm, _L("RMobilePhone::GetHomeNetwork did not return ENetworkModeGsm as expected"));

  1017 	

  1018 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iNetworkId with length > 0

  1019 	ASSERT_TRUE(homeNWInfo.iNetworkId.Length() > 0, _L("RMobilePhone::GetHomeNetwork returns invalid iNetworkId"));

  1020 	

  1021 	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iShortName with length > 0

  1022 	ASSERT_TRUE(homeNWInfo.iShortName.Length() > 0, _L("RMobilePhone::GetHomeNetwork returns invalid iShortName"));

  1023 	

  1024 	// $CTSYProblem 

  1025 	// GetHomeNetwork() doesn't return correct NetworkInfo.iStatus

  1026     

  1027   	// Check RMobilePhone::GetHomeNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iStatus= ENetworkStatusUnknown

  1028     ASSERT_EQUALS(homeNWInfo.iStatus, RMobilePhone::ENetworkStatusUnknown , _L("RMobilePhone::GetHomeNetwork did not return ENetworkStatusUnknown status as expected "));

  1029 

  1030 	// ===  Get the current network information. ===

  1031 	RMobilePhone::TMobilePhoneNetworkInfoV5 currentNWInfo;

  1032     RMobilePhone::TMobilePhoneLocationAreaV1 currentLocation;

  1033     RMobilePhone::TMobilePhoneNetworkInfoV5Pckg currentNWInfoPckg(currentNWInfo);

  1034     TExtEtelRequestStatus getCurrentNetworkStatus(phone, EMobilePhoneGetCurrentNetwork);	

  1035 	CleanupStack::PushL(getCurrentNetworkStatus);

  1036 	phone.GetCurrentNetwork(getCurrentNetworkStatus, currentNWInfoPckg, currentLocation);

  1037 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCurrentNetworkStatus, ETimeLong), KErrNone, _L("RMobilePhone::GetCurrentNetwork timed out"));

  1038 	ASSERT_EQUALS(getCurrentNetworkStatus.Int(), KErrNone, _L("RMobilePhone::GetCurrentNetwork returned an error"));

  1039 

  1040 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iCountryCode with length > 0

  1041 	ASSERT_TRUE(currentNWInfo.iCountryCode.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iCountryCode"));			

  1042 	

  1043 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iDisplayTag with length > 0

  1044 	ASSERT_TRUE(currentNWInfo.iDisplayTag.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid Display Tag"));			

  1045 	

  1046 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iLongName with length > 0

  1047 	ASSERT_TRUE(currentNWInfo.iLongName.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iLongName"));			

  1048 

  1049 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iMode=ENetworkModeGsm or ENetworkModeWcdma

  1050 	ASSERT_TRUE(currentNWInfo.iMode == RMobilePhone::ENetworkModeGsm || currentNWInfo.iMode == RMobilePhone::ENetworkModeWcdma, _L("RMobilePhone::GetCurrentNetwork did not return ENetworkModeGsm as expected"));		

  1051 

  1052 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iNetworkId with length > 0

  1053 	ASSERT_TRUE(currentNWInfo.iNetworkId.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iNetworkId"));			

  1054 

  1055 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iShortName with length > 0

  1056 	ASSERT_TRUE(currentNWInfo.iShortName.Length() > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iShortName"));			

  1057 

  1058 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneNetworkInfoV5 returns aNetworkInfo.iStatus=ENetworkStatusCurrent

  1059 	ASSERT_EQUALS(currentNWInfo.iStatus, RMobilePhone::ENetworkStatusCurrent , _L("RMobilePhone::GetCurrentNetwork did not return ENetworkStatusCurrent status as expected "));			

  1060 

  1061 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneLocationAreaV1 returns aArea.iCellId > 0

  1062 	ASSERT_TRUE(currentLocation.iCellId > 0, _L("RMobilePhone::GetCurrentNetwork returned invalid iCellId"));

  1063 			

  1064 	// Check RMobilePhone::GetCurrentNetwork with parameter type TMobilePhoneLocationAreaV1 returns aArea.iLocationAreaCode > 0

  1065 	ASSERT_TRUE(currentLocation.iLocationAreaCode > 0, _L("RMobilePhone::GetCurrentNetwork returns invalid iLocationAreaCode"));

  1066 

  1067 	// Use helper class for CRetrieveMobilePhonePreferredNetworks to retrieve a list of preferred networks

  1068 	CRetrieveMobilePhonePreferredNetworksExec *netListHelper = CRetrieveMobilePhonePreferredNetworksHelper::NewL(phone);

  1069 	CleanupStack::PushL(netListHelper);

  1070 	TInt err;

  1071 	CMobilePhoneStoredNetworkList* prefNetList = netListHelper->DoGetList(err);

  1072 	ASSERT_EQUALS(err, KErrNotSupported, _L("CRetrieveMobilePhonePreferredNetworks::Start failed to get the list"));

  1073 	

  1074 	// $CTSYProblem CTSY does not support EMobilePhoneGetPreferredNetworksPhase1 and 

  1075 	// EMobilePhoneGetDetectedNetworksPhase1 IPCs.

  1076 	// If supported, "if (prefNetList != NULL)"-line can be commented/deleted

  1077     

  1078 	if (prefNetList != NULL)

  1079 		{

  1080 		// Check CMobilePhoneStoredNetworkList::Enumerate returns >= 1

  1081 		ASSERT_TRUE(prefNetList->Enumerate() >= 1, _L("CMobilePhoneStoredNetworkList::Enumerate did not return valid number of entries"));

  1082 

  1083 		// ===  Check first entry in preferred network list is the home network ===

  1084 

  1085 		// Check first item in the CMobilePhoneStoredNetworkList list contains a RMobilePhone::TMobilePreferredNetworkEntryV3 with

  1086 		const RMobilePhone::TMobilePreferredNetworkEntryV3 &prefInfo = prefNetList->GetEntryL(0);

  1087 

  1088 		// iAccess with caps in set of KNetworkAccessGsm

  1089 		ASSERT_BITS_SET(prefInfo.iAccess, RMobilePhone::KNetworkAccessGsm, KNoUnwantedBits,	_L("CMobilePhoneStoredNetworkList.GetEntry() returned first list item with invalid prefInfo.iAccess"));

  1090 

  1091 		// iCountryCode = aNetworkInfo.iCountryCode from RMobilePhone::GetHomeNetwork

  1092 		ASSERT_EQUALS_DES16(prefInfo.iCountryCode, homeNWInfo.iCountryCode, _L("CMobilePhoneStoredNetworkList.GetEntry() returned first list item with invalid prefInfo.iCountryCode. Not equal to home network"));

  1093 

  1094 		// iNetworkId = aNetworkInfo.iNetworkId from RMobilePhone::GetHomeNetwork 

  1095 		ASSERT_EQUALS_DES16(prefInfo.iNetworkId, homeNWInfo.iNetworkId, _L("CMobilePhoneStoredNetworkList.GetEntry() returned first list item with invalid prefInfo.iNetworkId. Not equal to home network"));

  1096 		}

  1097 	

  1098 	//

  1099 	// TEST END

  1100 	//

  1101 

  1102     StartCleanup();

  1103     

  1104     //searchPeriodReqStatus

  1105     //getHomeNetworkStatus

  1106     //getCurrentNetworkStatus

  1107     //netListHelper

  1108 	CleanupStack::PopAndDestroy(4, &searchPeriodReqStatus);

  1109     

  1110 	return TestStepResult();

  1111 	}

  1112 

  1113 TPtrC CCTSYIntegrationTestNetworkControl0005::GetTestStepName()

  1114 /**

  1115  * @return The test step name.

  1116  */

  1117 	{

  1118 	return _L("CCTSYIntegrationTestNetworkControl0005");

  1119 	}

  1120 

  1121 

  1122 

  1123 CCTSYIntegrationTestNetworkControl0006::CCTSYIntegrationTestNetworkControl0006(CEtelSessionMgr& aEtelSessionMgr)

  1124 	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

  1125 /**

  1126  * Constructor.

  1127  */

  1128 	{

  1129 	SetTestStepName(CCTSYIntegrationTestNetworkControl0006::GetTestStepName());

  1130 	}

  1131 

  1132 CCTSYIntegrationTestNetworkControl0006::~CCTSYIntegrationTestNetworkControl0006()

  1133 /**

  1134  * Destructor.