// 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:

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

// 

//

/**

 @file 

*/

#include "cctsycallforwardingfu.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 "cctsyactiveretriever.h"

#include <mmretrieve.h>

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestStart0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestStart0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestStart0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestStart0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestStart0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestSetCallForwardingStatus0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestSetCallForwardingStatus0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestSetCallForwardingStatus0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestSetCallForwardingStatus0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestSetCallForwardingStatus0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestGetCallForwardingIndicator0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestNotifyCallForwardingActive0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestNotifyCallForwardingActive0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestNotifyCallForwardingActive0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestNotifyCallForwardingStatusChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestNotifyCallForwardingStatusChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallForwardingFU, TestNotifyCallForwardingStatusChange0004L);

	END_SUITE;

	}

//

// Actual test cases

//

void CCTsyCallForwardingFU::AuxTestStart0001L(

		RMobilePhone::TMobileService aServiceGroup,

		RMobilePhone::TMobileInfoLocation aLocation)

	{

	RBuf8 data;

	CleanupClosePushL(data);

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CRetrieveMobilePhoneCFList* asyncRetrieveMobilePhoneCFList =

	                                       CRetrieveMobilePhoneCFList::NewL(iPhone);    

	CleanupStack::PushL(asyncRetrieveMobilePhoneCFList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCFList);

	CleanupStack::PushL(activeRetriever);

	scheduler.AddRetrieverL(*activeRetriever);

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

	// TEST A: failure to dispatch request to LTSY

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

	RMobilePhone::TMobilePhoneCFCondition condition(RMobilePhone::ECallForwardingUnconditional);

	RMobilePhone::TMobilePhoneCFCondition expCondition(condition);

	RMobilePhone::TMobileService expServiceGroup(aServiceGroup);

	TMockLtsyData2<RMobilePhone::TMobilePhoneCFCondition, RMobilePhone::TMobileService>

    		                                          expLtsyData(expCondition, expServiceGroup);

	expLtsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobilePhoneGetCallForwardingStatusPhase1, data, KErrNotSupported);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, aServiceGroup, aLocation);

	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

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

    iMockLTSY.ExpectL(EMobilePhoneGetCallForwardingStatusPhase1, data);

    CMobilePhoneCFList* completeCFList( NULL );

	TMockLtsyData1<CMobilePhoneCFList*> completeData(completeCFList);

	data.Close();

	completeData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobilePhoneGetCallForwardingStatusPhase1, KErrGeneral, data);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, aServiceGroup, aLocation);

	activeRetriever->Activate();

	scheduler.StartScheduler();

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

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

	AssertMockLtsyStatusL();

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

	// TEST B: increase coverage (completion with null pointer)

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

	data.Close();

	expLtsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobilePhoneGetCallForwardingStatusPhase1, data);

	data.Close();

	completeData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobilePhoneGetCallForwardingStatusPhase1, KErrNone, data);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, aServiceGroup, aLocation);

	activeRetriever->Activate();

	scheduler.StartScheduler();

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

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

	AssertMockLtsyStatusL();

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

	// TEST B: increase coverage (completion with empty array)

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

	data.Close();

	expLtsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobilePhoneGetCallForwardingStatusPhase1, data);

    completeCFList = CMobilePhoneCFList::NewL();

	CleanupStack::PushL(completeCFList);

	data.Close();

	completeData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobilePhoneGetCallForwardingStatusPhase1, KErrNone, data);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, aServiceGroup, aLocation);

	activeRetriever->Activate();

	scheduler.StartScheduler();

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

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

	AssertMockLtsyStatusL();

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

	// TEST C: Successful completion request of

	// CRetrieveMobilePhoneCFList::Start when result is not cached.

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

	data.Close();

	expLtsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobilePhoneGetCallForwardingStatusPhase1, data);

	RMobilePhone::TMobilePhoneCFInfoEntryV1	entryCFInfoEntry;

	entryCFInfoEntry.iTimeout              = 20;

	entryCFInfoEntry.iCondition            = RMobilePhone::ECallForwardingUnconditional;

	entryCFInfoEntry.iServiceGroup         = RMobilePhone::EVoiceService;

	entryCFInfoEntry.iStatus               = RMobilePhone::ECallForwardingStatusNotProvisioned;

	entryCFInfoEntry.iNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;

	entryCFInfoEntry.iNumber.iNumberPlan   = RMobilePhone::EIsdnNumberPlan;

	entryCFInfoEntry.iNumber.iTelNumber.Copy(_L("+441632960000"));

	completeCFList->AddEntryL(entryCFInfoEntry);

	data.Close();

	completeData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobilePhoneGetCallForwardingStatusPhase1, KErrNone, data);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, aServiceGroup, aLocation);

	activeRetriever->Activate();

	scheduler.StartScheduler();

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

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

	CMobilePhoneCFList* list = asyncRetrieveMobilePhoneCFList->RetrieveListL();

	CleanupStack::PushL( list );

	ASSERT_TRUE( TComparator<CMobilePhoneCFList>::IsEqual(*completeCFList, *list) );

	CleanupStack::PopAndDestroy( list );

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3); // completeCFList, activeRetriever, asyncRetrieveMobilePhoneCFList

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(&data);

	}

/**

@SYMTestCaseID BA-CTSY-CFOR-RMPCFLN-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhoneCFList::Start

@SYMTestPriority High

@SYMTestActions Invokes CRetrieveMobilePhoneCFList::Start

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallForwardingFU::TestStart0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobilePhone::TMobileService serviceGroup(RMobilePhone::EServiceUnspecified);

	while ( serviceGroup != RMobilePhone::EFaxService )

		{

		GetNextServiceGroup(serviceGroup);

		AuxTestStart0001L(serviceGroup, RMobilePhone::EInfoLocationCachePreferred);

		AuxTestStart0001L(serviceGroup, RMobilePhone::EInfoLocationNetwork);

		}

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

	// TEST: failure to dispatch request to CTSY

	// when information is taken from cache

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

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CRetrieveMobilePhoneCFList* asyncRetrieveMobilePhoneCFList =

	                                       CRetrieveMobilePhoneCFList::NewL(iPhone);    

	CleanupStack::PushL(asyncRetrieveMobilePhoneCFList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCFList);

	CleanupStack::PushL(activeRetriever);

	scheduler.AddRetrieverL(*activeRetriever);

	// test

	serviceGroup = RMobilePhone::EServiceUnspecified;

	while ( serviceGroup != RMobilePhone::EFaxService )

		{

		GetNextServiceGroup(serviceGroup);

		asyncRetrieveMobilePhoneCFList->Start(

				activeRetriever->iStatus,

				RMobilePhone::ECallForwardingUnconditional,

				serviceGroup,

				RMobilePhone::EInfoLocationCache);

		activeRetriever->Activate();

		scheduler.StartScheduler();

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

		// Request completes with KErrNotFound because

		// CTSY does not have a cache for CFList

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

		AssertMockLtsyStatusL();

		}

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

	// TEST E: Unsolicited completion of CRetrieveMobilePhoneCFList::Start

	// from LTSY.

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

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

	RBuf8 data;

	CleanupClosePushL(data);

    CMobilePhoneCFList* completeCFList( NULL );

	TMockLtsyData1<CMobilePhoneCFList*> completeData(completeCFList);

	completeData.SerialiseL(data);

	iMockLTSY.CompleteL(EMobilePhoneGetCallForwardingStatusPhase1, KErrNone, data);

	User::WaitForRequest(mockLtsyStatus);

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3); // data, activeRetriever, asyncRetrieveMobilePhoneCFList

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(this);

	}

/**

@SYMTestCaseID BA-CTSY-CFOR-RMPCFLN-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of CRetrieveMobilePhoneCFList::Start

@SYMTestPriority High

@SYMTestActions Invokes cancelling of CRetrieveMobilePhoneCFList::Start

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallForwardingFU::TestStart0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	RBuf8 data;

	CleanupClosePushL(data);

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CRetrieveMobilePhoneCFList* asyncRetrieveMobilePhoneCFList =

	                                       CRetrieveMobilePhoneCFList::NewL(iPhone);    

	CleanupStack::PushL(asyncRetrieveMobilePhoneCFList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCFList);

	CleanupStack::PushL(activeRetriever);

	scheduler.AddRetrieverL(*activeRetriever);

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

	// Test cancelling of CRetrieveMobilePhoneCFList::Start

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

	RMobilePhone::TMobilePhoneCFCondition expCondition(RMobilePhone::ECallForwardingUnconditional);

	RMobilePhone::TMobileService expServiceGroup(RMobilePhone::EVoiceService);

	TMockLtsyData2<RMobilePhone::TMobilePhoneCFCondition, RMobilePhone::TMobileService>

    		                                          expLtsyData(expCondition, expServiceGroup);

	expLtsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobilePhoneGetCallForwardingStatusPhase1, data);

	CMobilePhoneCFList* completeCFList = CMobilePhoneCFList::NewL();

	CleanupStack::PushL(completeCFList);

	RMobilePhone::TMobilePhoneCFInfoEntryV1	entryCFInfoEntry;

	entryCFInfoEntry.iTimeout              = 20;

	entryCFInfoEntry.iCondition            = RMobilePhone::ECallForwardingUnconditional;

	entryCFInfoEntry.iServiceGroup         = RMobilePhone::EVoiceService;

	entryCFInfoEntry.iStatus               = RMobilePhone::ECallForwardingStatusNotProvisioned;

	entryCFInfoEntry.iNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;

	entryCFInfoEntry.iNumber.iNumberPlan   = RMobilePhone::EIsdnNumberPlan;

	entryCFInfoEntry.iNumber.iTelNumber.Copy(_L("+441632960000"));

	completeCFList->AddEntryL(entryCFInfoEntry);

	TMockLtsyData1<CMobilePhoneCFList*> completeData(completeCFList);

	data.Close();

	completeData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobilePhoneGetCallForwardingStatusPhase1, KErrNone, data, 10);

	RMobilePhone::TMobilePhoneCFCondition condition(expCondition);

	RMobilePhone::TMobileService serviceGroup(expServiceGroup);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, serviceGroup);

	activeRetriever->Activate(CActiveRetriever::ECaseGeneralCancelCase);

	scheduler.StartScheduler();

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

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

	// Wait for completion of iMockLTSY.NotifyTerminated

	User::WaitForRequest(mockLtsyStatus);

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	AssertMockLtsyStatusL();

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

	// Test cancelling of CRetrieveMobilePhoneCFList::Start

	// this time cancel on 2nd phase

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

	data.Close();

	expLtsyData.SerialiseL(data);

    iMockLTSY.ExpectL(EMobilePhoneGetCallForwardingStatusPhase1, data);

	data.Close();

	completeData.SerialiseL(data);

    iMockLTSY.CompleteL(EMobilePhoneGetCallForwardingStatusPhase1, KErrNone, data);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, serviceGroup);

	activeRetriever->Activate(CActiveRetriever::ECasePhase2Cancel);

	scheduler.StartScheduler();

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

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

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3); // completeCFList, activeRetriever, asyncRetrieveMobilePhoneCFList

	CActiveScheduler::Install(NULL);

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

	}

/**

@SYMTestCaseID BA-CTSY-CFOR-RMPCFLN-0003

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhoneCFList::Start with bad parameter data

@SYMTestPriority High

@SYMTestActions Invokes CRetrieveMobilePhoneCFList::Start with bad parameter data

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallForwardingFU::TestStart0003L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CRetrieveMobilePhoneCFList* asyncRetrieveMobilePhoneCFList =

	                                       CRetrieveMobilePhoneCFList::NewL(iPhone);    

	CleanupStack::PushL(asyncRetrieveMobilePhoneCFList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCFList);

	CleanupStack::PushL(activeRetriever);

	scheduler.AddRetrieverL(*activeRetriever);

	RMobilePhone::TMobilePhoneCFCondition condition(RMobilePhone::ECallForwardingUnconditional);

	RMobilePhone::TMobileService serviceGroup(RMobilePhone::EVoiceService);

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

	// Test C: Test passing out of bounds parameters to

	// CRetrieveMobilePhoneCFList::Start

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

	condition = RMobilePhone::ECallForwardingAllCases; // not supported

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, serviceGroup);

	activeRetriever->Activate();

	scheduler.StartScheduler();

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

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

	AssertMockLtsyStatusL();

	condition = RMobilePhone::ECallForwardingAllConditionalCases; // not supported

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, serviceGroup);

	activeRetriever->Activate();

	scheduler.StartScheduler();

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

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

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(2); // activeRetriever, asyncRetrieveMobilePhoneCFList

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(this);

	}

/**

@SYMTestCaseID BA-CTSY-CFOR-RMPCFLN-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to CRetrieveMobilePhoneCFList::Start

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to CRetrieveMobilePhoneCFList::Start

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallForwardingFU::TestStart0004L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	CFilteringActiveScheduler scheduler;

	CActiveScheduler::Install(&scheduler);

	CRetrieveMobilePhoneCFList* asyncRetrieveMobilePhoneCFList =

	                                       CRetrieveMobilePhoneCFList::NewL(iPhone);    

	CleanupStack::PushL(asyncRetrieveMobilePhoneCFList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCFList);

	CleanupStack::PushL(activeRetriever);

	scheduler.AddRetrieverL(*activeRetriever);

	// Open second client

	RTelServer telServer2;

	TInt ret = telServer2.Connect();

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(telServer2);

	RMobilePhone phone2;

	ret = phone2.Open(telServer2, KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(phone2);

	CRetrieveMobilePhoneCFList* asyncRetrieveMobilePhoneCFList2 =

	                                       CRetrieveMobilePhoneCFList::NewL(phone2);

	CleanupStack::PushL(asyncRetrieveMobilePhoneCFList2);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever2 = 

						CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCFList2);

	CleanupStack::PushL(activeRetriever2);

	scheduler.AddRetrieverL(*activeRetriever2);

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