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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Test step definitions for the NetworkControl functional unit.

// 

//

/**

 @internalTechnology

*/

#include <etelpckt.h>

#include <pcktcs.h>

#include "cctsyintegrationtestnetworkcontrol.h"

#include "listretrievalhelpers.h"

#include "cctsyinidata.h"

CCTSYIntegrationTestNetworkControlBase::CCTSYIntegrationTestNetworkControlBase(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), 

		iNetworkTestHelper(*this),

		iCallControlTestHelper(*this),

		iPacketServiceTestHelper(*this)

/**

 * Constructor

 */

	{

	}

CCTSYIntegrationTestNetworkControlBase::~CCTSYIntegrationTestNetworkControlBase()

/*

 * Destructor

 */

	{

	}

/** 

* Check a preferred network entry is in the list

* 

* @param aList The list to search.

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

* 

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

*/

TBool CCTSYIntegrationTestNetworkControlBase::IsPreferredNetworkInListL( 

								CMobilePhoneStoredNetworkList& aList, 

								RMobilePhone::TMobilePreferredNetworkEntryV3& aTarget)

	{

	TInt listCount = aList.Enumerate(); 

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

		{

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

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

			netInfo.iCountryCode == aTarget.iCountryCode &&

			netInfo.iNetworkId == aTarget.iNetworkId )

			{

			return ETrue;

			}

		}

	return EFalse;

	}

void CCTSYIntegrationTestNetworkControlBase::SetAttachModeToWhenPossibleAndWaitForAttachL(RPacketService& aPacketService)

/**

 * Attaches the phone to the packet service by setting the

 * attach mode to RPacketService::EAttachWhenPossible. Requests

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

 * attach to complete.

 * 

 * @param aPacketService Reference to packet service subsession.

 */

    {

    RPacketService::TAttachMode attachMode;

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

    TExtEtelRequestStatus notifyServiceStatusChStatus(aPacketService, EPacketNotifyStatusChange);

    CleanupStack::PushL(notifyServiceStatusChStatus);

    RPacketService::TStatus packetServiceStatus;

    aPacketService.NotifyStatusChange(notifyServiceStatusChStatus, packetServiceStatus);

    if(attachMode != RPacketService::EAttachWhenPossible)

		{

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

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

		}

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

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

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

	RPacketService::TStatus packetStatus;

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

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

	if (packetStatus == RPacketService::EStatusUnattached)

		{

        iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(

				aPacketService,

				notifyServiceStatusChStatus,

				packetServiceStatus, 

				RPacketService::EStatusAttached,

				KErrNone);

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

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

		}

    CleanupStack::PopAndDestroy(1, &notifyServiceStatusChStatus);

    }

/**************************************************************************/

CCTSYIntegrationTestNetworkControl0001::CCTSYIntegrationTestNetworkControl0001(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestNetworkControl0001::GetTestStepName());

	}

CCTSYIntegrationTestNetworkControl0001::~CCTSYIntegrationTestNetworkControl0001()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestNetworkControl0001::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/NTWC-0001

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

 * @SYMTestPriority High

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

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

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * 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.

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

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

	iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone);

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

	TUint32 caps;

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

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

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

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

	RMobilePhone::TMobilePhoneNetworkSelectionV1 netSelSetting;

	RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg netSelSettingPkg(netSelSetting);

	CHECK_EQUALS_L( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

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

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

		{

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

		TExtEtelRequestStatus setNetSelSettingStatus(phone, EMobilePhoneSetNetworkSelectionSetting);

		CleanupStack::PushL(setNetSelSettingStatus);

		netSelSetting.iMethod = RMobilePhone::ENetworkSelectionAutomatic;

		phone.SetNetworkSelectionSetting( setNetSelSettingStatus, netSelSettingPkg );

		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setNetSelSettingStatus, ETimeLong), KErrNone, 

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

		CHECK_EQUALS_L( setNetSelSettingStatus.Int(), KErrNone, 

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

		CleanupStack::Pop(&setNetSelSettingStatus);

		}

	CHECK_EQUALS_L( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

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

	CHECK_EQUALS_L( netSelSetting.iMethod, RMobilePhone::ENetworkSelectionAutomatic, 

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

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

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

	RMobilePhone::TMobilePhoneNetworkInfoV1 homeNetworkInfo;

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

	TExtEtelRequestStatus getHomeNetworkStatus(phone, EMobilePhoneGetHomeNetwork);

	CleanupStack::PushL(getHomeNetworkStatus);

	phone.GetHomeNetwork( getHomeNetworkStatus, homeInfoPkg );

	ASSERT_EQUALS(WaitForRequestWithTimeOut(getHomeNetworkStatus, ETimeLong), KErrNone, 

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

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

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

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

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

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

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

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

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

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

	TExtEtelRequestStatus notifyNetSelSettingChange( phone, EMobilePhoneNotifyNetworkSelectionSettingChange);

	CleanupStack::PushL(notifyNetSelSettingChange);

	RMobilePhone::TMobilePhoneNetworkSelectionV1 netSelNotify;

	RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg netSelNotifyPkg( netSelNotify );

	phone.NotifyNetworkSelectionSettingChange(notifyNetSelSettingChange, netSelNotifyPkg);

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

	// aSetting.iMethod = ENetworkSelectionManual

	TExtEtelRequestStatus setNetSelSettingStatus(phone, EMobilePhoneSetNetworkSelectionSetting);

	CleanupStack::PushL(setNetSelSettingStatus);

	netSelSetting.iMethod = RMobilePhone::ENetworkSelectionManual;

	phone.SetNetworkSelectionSetting( setNetSelSettingStatus, netSelSettingPkg );

	ASSERT_EQUALS(WaitForRequestWithTimeOut(setNetSelSettingStatus, ETimeLong), KErrNone, 

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

	ASSERT_EQUALS( setNetSelSettingStatus.Int(), KErrNone, 

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

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

	// Check RMobilePhone::NotifyNetworkSelectionSettingChange completes with 

	// aSetting.iMethod = ENetworkSelectionManual

	iNetworkTestHelper.WaitForMobilePhoneNotifyNetworkSelectionSettingChange(phone,

													notifyNetSelSettingChange,netSelNotify, 

													RMobilePhone::ENetworkSelectionManual, KErrNone);

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

	ASSERT_EQUALS( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

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

	ASSERT_EQUALS( netSelSetting.iMethod, RMobilePhone::ENetworkSelectionManual, 

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

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

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

	// Store list for use later. 

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

	CleanupStack::PushL( netListHelper );

	TInt err;

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

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

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

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

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

	CRetrieveMobilePhoneDetectedNetworksExec *detectedNetListHelper = 

				CRetrieveMobilePhoneDetectedNetworksHelper::NewL(phone,ERetrieveListV1);

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

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

	// $CTSYProblem CTSY does not support EMobilePhoneGetPreferredNetworksPhase1 and 

	// EMobilePhoneGetDetectedNetworksPhase1 IPCs.

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

	// and the CleanupStack items sorted out.

	/*	

	TInt detectedNetCount = detectedNetList->Enumerate();

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

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

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

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

	// from RMobilePhone::GetHomeNetwork)

	const RMobilePhone::TMobilePhoneNetworkInfoV1 *notHomeNetworkInfo = NULL;

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

		{

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

		if( netInfo.iNetworkId != homeNetworkInfo.iNetworkId )

			{

			notHomeNetworkInfo = &netInfo;

			break;

			}

		}

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

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

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

	//  Select network with RMobilePhone::SelectNetwork with 

	// aIsManual=ETrue and 

	// aManualSelection.iCountry=TMobilePhoneNetworkInfoV1::iCountryCode and 

	// aManualSelection.iNetwork=TMobilePhoneNetworkInfoV1::iNetworkId 

	TExtEtelRequestStatus reqSetNetworkStatus(phone, EMobilePhoneSelectNetwork);

	CleanupStack::PushL(reqSetNetworkStatus);	

	RMobilePhone::TMobilePhoneNetworkManualSelection manNetSel;

	manNetSel.iCountry = notHomeNetworkInfo->iCountryCode;

	manNetSel.iNetwork = notHomeNetworkInfo->iNetworkId;

	phone.SelectNetwork(reqSetNetworkStatus, ETrue, manNetSel );

	ASSERT_EQUALS( WaitForRequestWithTimeOut(reqSetNetworkStatus, ETimeLong ), KErrNone, 

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

	//  Check this returns error != KErrorNone 

	ASSERT_TRUE( KErrNone != reqSetNetworkStatus.Int(),	

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

	//  Check RMobilePhone::GetNetworkRegistrationStatus returns aStatus=ERegistrationDenied 

	RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus;

	iNetworkTestHelper.GetNetworkRegistrationStatusL(phone, registrationStatus);

	ASSERT_EQUALS(registrationStatus, RMobilePhone::ERegistrationDenied, 

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

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

	// Select network with RMobilePhone::SelectNetwork with 

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

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

	manNetSel.iCountry = homeNetworkInfo.iCountryCode;

	manNetSel.iNetwork = homeNetworkInfo.iNetworkId;

	phone.SelectNetwork(reqSetNetworkStatus, ETrue, manNetSel );

	ASSERT_EQUALS( WaitForRequestWithTimeOut(reqSetNetworkStatus, ETimeLong ), KErrNone, 

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

	//  Check this returns error != KErrorNone 

	ASSERT_TRUE( KErrNone != reqSetNetworkStatus.Int(),	

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

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

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

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

	CleanupStack::PushL( checkNetListHelper );

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

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

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

	// first preferred network list.

	TInt prefListCount = prefNetList->Enumerate();

	TInt checkListCount = checkPrefNetList->Enumerate();

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

	if(  prefListCount == checkListCount )

		{

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

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

			{

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

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

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

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

			}

		}

	*/	

	// Repost the notification request

	phone.NotifyNetworkSelectionSettingChange(notifyNetSelSettingChange, netSelNotifyPkg);

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

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

	// with aSetting.iMethod = ENetworkSelectionAutomatic 

	netSelSetting.iMethod = RMobilePhone::ENetworkSelectionAutomatic;

	phone.SetNetworkSelectionSetting( setNetSelSettingStatus, netSelSettingPkg );

	ASSERT_EQUALS(WaitForRequestWithTimeOut(setNetSelSettingStatus, ETimeLong), KErrNone, 

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

	ASSERT_EQUALS( setNetSelSettingStatus.Int(), KErrNone, 

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

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

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

	iNetworkTestHelper.WaitForMobilePhoneNotifyNetworkSelectionSettingChange(phone, 

															notifyNetSelSettingChange, netSelNotify, 

															RMobilePhone::ENetworkSelectionAutomatic,

															KErrNone);	

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

	ASSERT_EQUALS( phone.GetNetworkSelectionSetting( netSelSettingPkg ), KErrNone, 

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

	ASSERT_EQUALS( netSelSetting.iMethod, RMobilePhone::ENetworkSelectionAutomatic, 

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

	//

	// TEST END

	//

    StartCleanup();

	// netListHelper

	// setNetSelSettingStatus

	// notifyNetSelSettingChange

    // getHomeNetworkStatus

	CleanupStack::PopAndDestroy(4,&getHomeNetworkStatus);

	return TestStepResult();

	}

TPtrC CCTSYIntegrationTestNetworkControl0001::GetTestStepName()

/**

 * @return The test step name.

 */

	{

	return _L("CCTSYIntegrationTestNetworkControl0001");

	}

CCTSYIntegrationTestNetworkControl0002::CCTSYIntegrationTestNetworkControl0002(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestNetworkControlBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestNetworkControl0002::GetTestStepName());

	}

CCTSYIntegrationTestNetworkControl0002::~CCTSYIntegrationTestNetworkControl0002()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestNetworkControl0002::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/NTWC-0002

 * @SYMTestCaseDesc Basic cell selection

 * @SYMTestPriority High

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

 * @SYMTestExpectedResults Pass - Phone camps on a cell

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

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

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

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

	iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone);

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

	TUint32 networkCaps=0;

	CHECK_EQUALS_L(mobilePhone.GetNetworkCaps(networkCaps), KErrNone,

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

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

						  | RMobilePhone::KCapsGetCurrentNetwork | RMobilePhone::KCapsGetHomeNetwork;

	CHECK_BITS_SET_L(networkCaps, expectedCaps, KNoUnwantedBits,

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

	//