// Copyright (c) 2007-2010 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:

// The TEFUnit test suite for NetworkControl in the Common TSY.

// 

//

/**

 @file 

*/

#include "cctsynetworkcontrolfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

#include "mmretrieve.h"

#include "cctsyactiveretriever.h"

#include "utils.h"

const TInt KOneSecond=1000000;	// Used in a time out function, 1 second (in microSeconds)

CTestSuite* CCTsyNetworkControlFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStartV20001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStartV20002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStartV20004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStartV20005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStart0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNITZInfo0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNITZInfo0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSelectNetwork0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSelectNetwork0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSelectNetwork0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSelectNetwork0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentMode0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetwork0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetwork0001aL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetwork0001bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetwork0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetwork0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetwork0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetwork0004bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkCaps0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyModeChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyModeChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyModeChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetwork0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetwork0001bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetwork0002L)

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetwork0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetwork0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetwork0004bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNITZInfoChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNITZInfoChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNITZInfoChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetworkName0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetworkName0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCurrentNetworkName0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetServiceProviderName0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetServiceProviderName0001aL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetServiceProviderName0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetServiceProviderName0002bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetServiceProviderName0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetServiceProviderName0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetServiceProviderName0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkInvScanSetting0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkInvScanEvent0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetHomeNetworkSearchPeriod0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkSelectionSetting0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkSelectionSetting0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCurrentNetworkChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCurrentNetworkChange0001bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCurrentNetworkChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCurrentNetworkChange0002bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCurrentNetworkChange0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCurrentNetworkChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCurrentNetworkChange0004bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkInvScanChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSetNetworkSelectionSetting0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSetNetworkSelectionSetting0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSetNetworkSelectionSetting0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSetNetworkSelectionSetting0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestSetNetworkSelectionSetting0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetLastUsedAccessTechnology0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001aL);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0001bL);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStorePreferredNetworksListL0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001aL);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001bL);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0001cL);

    ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestRetrieveMobilePhonePreferredNetworks0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetNetworkRegistrationStatus0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyPreferredNetworksListChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkSelectionSettingChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkRegistrationStatusChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkRegistrationStatusChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyNetworkRegistrationStatusChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestStartV50001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCellInfo0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCellInfo0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCellInfo0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestGetCellInfo0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCellInfoChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCellInfoChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCellInfoChange0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyNetworkControlFU, TestNotifyCellInfoChange0004L);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-NTWC-RMPDNS-0001

@SYMPREQ 1551

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhoneDetectedNetworks::StartV2

@SYMTestPriority High

@SYMTestActions Invokes CRetrieveMobilePhoneDetectedNetworks::StartV2

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyNetworkControlFU::TestStartV20001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CRetrieveMobilePhoneDetectedNetworks* retrieveMobilePhoneDetectedNetworks = 

	                         CRetrieveMobilePhoneDetectedNetworks::NewL(iPhone);

	CleanupStack::PushL(retrieveMobilePhoneDetectedNetworks);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*retrieveMobilePhoneDetectedNetworks);

	CleanupStack::PushL(activeRetriever);

	scheduler.AddRetrieverL(*activeRetriever);

 	//-------------------------------------------------------------------------

	// TEST A: failure to dispatch request to LTSY

 	//-------------------------------------------------------------------------

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNotSupported);

	retrieveMobilePhoneDetectedNetworks->StartV2(activeRetriever->Status());

	activeRetriever->Activate();

	scheduler.StartScheduler();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrNotSupported, activeRetriever->iStatus.Int());

	AssertMockLtsyStatusL();

	//-------------------------------------------------------------------------

	// TEST B: failure on completion of pending request from LTSY->CTSY

 	//-------------------------------------------------------------------------

 	// --- prepare data for CompleteL ---

 	CMobilePhoneNetworkListV2* networkListV2 = CMobilePhoneNetworkListV2::NewL();

	CleanupStack::PushL(networkListV2);

	TMockLtsyData1<CMobilePhoneNetworkListV2*> listData(networkListV2);

 	RMobilePhone::TMobilePhoneNetworkInfoV2 infoV2;

	infoV2.iAccess      = RMobilePhone::ENetworkAccessUnknown;

	infoV2.iMode        = RMobilePhone::ENetworkModeUnknown;

	infoV2.iStatus      = RMobilePhone::ENetworkStatusUnknown;

	infoV2.iBandInfo    = RMobilePhone::EBandUnknown;	

	_LIT(KCountryCode, "1234");

	infoV2.iCountryCode = KCountryCode;

	_LIT(KCdmaSID, "12345678");

	infoV2.iCdmaSID     = KCdmaSID;

	_LIT(KAnalogSID, "12345678");

	infoV2.iAnalogSID   = KAnalogSID;

	_LIT(KNetworkId, "12345678");

	infoV2.iNetworkId   = KNetworkId;

	_LIT(KDisplayTag, "1234567890");

	infoV2.iDisplayTag  = KDisplayTag;

	_LIT(KShortName, "1234567890");

	infoV2.iShortName   = KShortName;

	_LIT(KLongName, "12345678901234567890");

	infoV2.iLongName    = KLongName;

	networkListV2->AddEntryL(infoV2);

	listData.SerialiseL(data); 

 	// --- -------------------------- ---

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone);

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrGeneral, data);

	retrieveMobilePhoneDetectedNetworks->StartV2(activeRetriever->Status());

	activeRetriever->Activate();

	scheduler.StartScheduler();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrGeneral, activeRetriever->iStatus.Int());

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST C: Successful completion request of

	// CRetrieveMobilePhoneDetectedNetworks::StartV2 when result is not cached.

 	//-------------------------------------------------------------------------

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone);

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone, data);

	retrieveMobilePhoneDetectedNetworks->StartV2(activeRetriever->Status());

	activeRetriever->Activate();

	scheduler.StartScheduler();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int());

	AssertMockLtsyStatusL();

	CMobilePhoneNetworkListV2* retrieveList = NULL;

	retrieveList = retrieveMobilePhoneDetectedNetworks->RetrieveListV2L();

	if ( retrieveList )

		{

		TInt index(0);

		RMobilePhone::TMobilePhoneNetworkInfoV2 retrieveInfo;

		CleanupStack::PushL(retrieveList);

		retrieveInfo = retrieveList->GetEntryL(index);

		ASSERT_EQUALS( RMobilePhone::ENetworkAccessUnknown, retrieveInfo.iAccess   );

		ASSERT_EQUALS( RMobilePhone::ENetworkModeUnknown  , retrieveInfo.iMode     );

		ASSERT_EQUALS( RMobilePhone::ENetworkStatusUnknown, retrieveInfo.iStatus   );

		ASSERT_EQUALS( RMobilePhone::EBandUnknown         , retrieveInfo.iBandInfo );

		ASSERT_EQUALS( 0, retrieveInfo.iCountryCode.Compare( KCountryCode ) );

		ASSERT_EQUALS( 0, retrieveInfo.iCdmaSID    .Compare( KCdmaSID     ) );

		ASSERT_EQUALS( 0, retrieveInfo.iAnalogSID  .Compare( KAnalogSID   ) );

		ASSERT_EQUALS( 0, retrieveInfo.iNetworkId  .Compare( KNetworkId   ) );

		ASSERT_EQUALS( 0, retrieveInfo.iDisplayTag .Compare( KDisplayTag  ) );

		ASSERT_EQUALS( 0, retrieveInfo.iShortName  .Compare( KShortName   ) );

		ASSERT_EQUALS( 0, retrieveInfo.iLongName   .Compare( KLongName    ) );

		CleanupStack::PopAndDestroy(1); // retrieveList

		}

 	//-------------------------------------------------------------------------

	// TEST E: Unsolicited completion of CRetrieveMobilePhoneDetectedNetworks::StartV2

	// from LTSY.

 	//-------------------------------------------------------------------------

	TRequestStatus requestStatus;

	iMockLTSY.NotifyTerminated(requestStatus);	

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone, data);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3); // retrieveMobilePhoneDetectedNetworks, 

	                                // activeAuthorizationInfoRetriever,

	                                // networkListV2

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(2, this); // data, this

	}

/**

@SYMTestCaseID BA-CTSY-NTWC-RMPDNS-0002

@SYMPREQ 1551

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of CRetrieveMobilePhoneDetectedNetworks::StartV2

@SYMTestPriority High

@SYMTestActions Invokes cancelling of CRetrieveMobilePhoneDetectedNetworks::StartV2

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyNetworkControlFU::TestStartV20002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CRetrieveMobilePhoneDetectedNetworks* retrieveMobilePhoneDetectedNetworks = 

	                         CRetrieveMobilePhoneDetectedNetworks::NewL(iPhone);

	CleanupStack::PushL(retrieveMobilePhoneDetectedNetworks);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*retrieveMobilePhoneDetectedNetworks);

	CleanupStack::PushL(activeRetriever);

	scheduler.AddRetrieverL(*activeRetriever);

	// --- prepare data for CompleteL ---

	CMobilePhoneNetworkListV2* networkListV2 = CMobilePhoneNetworkListV2::NewL();

	CleanupStack::PushL(networkListV2);

	TMockLtsyData1<CMobilePhoneNetworkListV2*> listData(networkListV2);

	RMobilePhone::TMobilePhoneNetworkInfoV2 infoV2;

	infoV2.iAccess      = RMobilePhone::ENetworkAccessUnknown;

	infoV2.iMode        = RMobilePhone::ENetworkModeUnknown;

	infoV2.iStatus      = RMobilePhone::ENetworkStatusUnknown;

	infoV2.iBandInfo    = RMobilePhone::EBandUnknown;

	_LIT(KCountryCode, "1234");

	infoV2.iCountryCode = KCountryCode;

	_LIT(KCdmaSID, "12345678");

	infoV2.iCdmaSID     = KCdmaSID;

	_LIT(KAnalogSID, "12345678");

	infoV2.iAnalogSID   = KAnalogSID;

	_LIT(KNetworkId, "12345678");

	infoV2.iNetworkId   = KNetworkId;

	_LIT(KDisplayTag, "1234567890");

	infoV2.iDisplayTag  = KDisplayTag;

	_LIT(KShortName, "1234567890");

	infoV2.iShortName   = KShortName;

	_LIT(KLongName, "12345678901234567890");

	infoV2.iLongName    = KLongName;

	networkListV2->AddEntryL(infoV2);

    listData.SerialiseL(data);

	//-------------------------------------------------------------------------

	// TEST B: failure on completion of pending request of

	// CRetrieveMobilePhoneDetectedNetworks::Cancel from LTSY->CTSY

 	//-------------------------------------------------------------------------

	iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone);

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksCancel, KErrNone);

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksCancel, KErrGeneral);

	retrieveMobilePhoneDetectedNetworks->StartV2(activeRetriever->Status());

	activeRetriever->Activate(CActiveRetriever::ECaseGeneralCancelCase);

	scheduler.StartScheduler();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	// status matchs KErrCancel because requests cancels in etel

	// before completion of cancel comes to CTSY

	// but completion of request in CTSY is awaited by etel

	// to release execution of the thread calling the Cancel

	ASSERT_EQUALS(KErrCancel, activeRetriever->iStatus.Int());

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST C: Successful completion request of

	// CRetrieveMobilePhoneDetectedNetworks::Cancel.

 	//-------------------------------------------------------------------------

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone);

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksCancel, KErrNone);

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksCancel, KErrNone);

	retrieveMobilePhoneDetectedNetworks->StartV2(activeRetriever->Status());

	activeRetriever->Activate(CActiveRetriever::ECaseGeneralCancelCase);

	scheduler.StartScheduler();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrCancel, activeRetriever->iStatus.Int());

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST D: Successful completion request of

	// CRetrieveMobilePhoneDetectedNetworks::Cancel on 2nd phase of

	// CRetrieveMobilePhoneDetectedNetworks::StartV2.

 	//-------------------------------------------------------------------------

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone);

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone, data);

	retrieveMobilePhoneDetectedNetworks->StartV2(activeRetriever->Status());

	activeRetriever->Activate(CActiveRetriever::ECasePhase2Cancel);

	scheduler.StartScheduler();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrCancel, activeRetriever->iStatus.Int());

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST E: Unsolicited completion of CRetrieveMobilePhoneDetectedNetworks::Cancel()

	// from LTSY.

 	//-------------------------------------------------------------------------

    TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksCancel, KErrNone);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST A: failure to dispatch request of

	// CRetrieveMobilePhoneDetectedNetworks::Cancel to LTSY

 	//-------------------------------------------------------------------------

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone);

    iMockLTSY.ExpectL(EMobilePhoneGetDetectedNetworksCancel, KErrNotSupported);

    iMockLTSY.CompleteL(EMobilePhoneGetDetectedNetworksV2Phase1, KErrNone, data);

	retrieveMobilePhoneDetectedNetworks->StartV2(activeRetriever->Status());

	activeRetriever->Activate(CActiveRetriever::ECaseGeneralCancelCase);

	scheduler.StartScheduler();

	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

	ASSERT_EQUALS(KErrCancel, activeRetriever->iStatus.Int());

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3); // retrieveMobilePhoneDetectedNetworks, 

	                                // activeRetriever,

	                                // networkListV2

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(2, this); // data, this

	}

/**

@SYMTestCaseID BA-CTSY-NTWC-RMPDNS-0004

@SYMPREQ 1551

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to CRetrieveMobilePhoneDetectedNetworks::StartV2

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to CRetrieveMobilePhoneDetectedNetworks::StartV2

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyNetworkControlFU::TestStartV20004L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	// Open second client

	RTelServer telServer2;

	TInt ret = telServer2.Connect();

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(telServer2);

	RMobilePhone phone2;

	ret = phone2.Open(iTelServer,KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(phone2);

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CMobilePhoneNetworkListV2* networkListV2 = CMobilePhoneNetworkListV2::NewL();

	CleanupStack::PushL(networkListV2);

	TMockLtsyData1<CMobilePhoneNetworkListV2*> listData(networkListV2);

	CRetrieveMobilePhoneDetectedNetworks* retrieveMobilePhoneDetectedNetworks1 = 

	                         CRetrieveMobilePhoneDetectedNetworks::NewL(iPhone);

	CleanupStack::PushL(retrieveMobilePhoneDetectedNetworks1);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever1 = 

						CActiveRetriever::NewL(*retrieveMobilePhoneDetectedNetworks1);

	CleanupStack::PushL(activeRetriever1);

	scheduler.AddRetrieverL(*activeRetriever1);

	CRetrieveMobilePhoneDetectedNetworks* retrieveMobilePhoneDetectedNetworks2 = 

	                         CRetrieveMobilePhoneDetectedNetworks::NewL(phone2);

	CleanupStack::PushL(retrieveMobilePhoneDetectedNetworks2);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever2 = 

						CActiveRetriever::NewL(*retrieveMobilePhoneDetectedNetworks2);

	CleanupStack::PushL(activeRetriever2);

	scheduler.AddRetrieverL(*activeRetriever2);