// 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 CallBarring functional unit.

// 

//

/**

 @internalTechnology

*/

#include "cctsyintegrationtestcallbarring.h"

#include "cctsyinidata.h"

_LIT(KAltPassword, "0000");

_LIT(KAltPassword2, "1234");

_LIT(KAltPassword4, "1235");

_LIT(KAltPassword5, "123");

_LIT(KAltPasswordVoda, "1919");

_LIT(KIncorrectPassword , "9999");

static const TInt KSsCallBarringAllServices=330;

CCTSYIntegrationTestCallBarringBase::CCTSYIntegrationTestCallBarringBase(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), 

		iSupplementalTsyTestHelper(*this),

		iCallControlTsyTestHelper(*this),

		iNetworkTsyTestHelper(*this)

/**

 * Constructor

 */

	{

	}

CCTSYIntegrationTestCallBarringBase::~CCTSYIntegrationTestCallBarringBase()

/*

 * Destructor

 */

	{

	}

/**

* Checks that the call barring password for this SIM is known and leaves if not

@param aPhone RMobilePhone session

@param aPassword On completion, the call barring password. The function leaves if this is not found.

*/

void CCTSYIntegrationTestCallBarringBase::CheckCBPasswordL( RMobilePhone &aPhone, RMobilePhone::TMobilePassword &aPassword )

	{

	DEBUG_PRINTF1(_L("Attempting to check call barring password is known"));

	// wait until we are on the network

	CHECK_EQUALS_L( iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL( aPhone ), KErrNone, 

						_L("Network is unavailable") );

	const TDesC* networkSection = NULL;

	iNetworkTsyTestHelper.GetNetworkPasswordsSectionL(aPhone,networkSection);

	// Get the password from the ini file

	TPtrC password; 

	TBool gotPass = GetStringFromConfig( *networkSection, KIniCallBarring1, password );

	CHECK_TRUE_L( gotPass, _L("Failed to read password from INI file"));

	// Check the call barring password by attempting to reset call barring for all services

	DEBUG_PRINTF2(_L("Checking call barring password from INI file %S"), &password);

	aPassword = password;

	TInt err = DeactivateCallBarringL( aPhone, aPassword );

	CHECK_EQUALS_L( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

	}

/**

* Resest call barring for all services

*/

TInt CCTSYIntegrationTestCallBarringBase::DeactivateCallBarringL( RMobilePhone &aPhone, 

																	const RMobilePhone::TMobilePassword& aPassword )

	{

	RMobilePhone::TMobilePhoneCBChangeV1 cbInfo;

	cbInfo.iAction = RMobilePhone::EServiceActionDeactivate;

	cbInfo.iPassword = aPassword;

	cbInfo.iServiceGroup = RMobilePhone::EAllServices;

	TExtEtelRequestStatus reqStatus(aPhone, EMobilePhoneSetCallBarringStatus);

	CleanupStack::PushL(reqStatus);

	aPhone.SetCallBarringStatus( reqStatus, RMobilePhone::EBarAllCases, cbInfo );

	TInt err = WaitForRequestWithTimeOut( reqStatus, ETimeMedium);

	if( KErrNone == err )

		{

		err = reqStatus.Int();

		}

	CleanupStack::PopAndDestroy(1,&reqStatus);

	return err;

	}

/** 

* Set the call barring status

*/

TInt CCTSYIntegrationTestCallBarringBase::SetCBStatusL( RMobilePhone& aPhone, 

						RMobilePhone::TMobilePhoneCBChangeV1& aInfo,

						RMobilePhone::TMobilePhoneCBCondition aCondition )

	{

	TExtEtelRequestStatus reqStatus(aPhone, EMobilePhoneSetCallBarringStatus);

	CleanupStack::PushL(reqStatus);

	aPhone.SetCallBarringStatus( reqStatus, aCondition, aInfo );

	TInt err = WaitForRequestWithTimeOut( reqStatus, ETimeMedium);

	if( KErrNone == err )

		{

		err = reqStatus.Int();

		}

	CleanupStack::PopAndDestroy(1);	

	return err;		

	}

/** 

* Search a status list for particular call barring entry

*/

TBool CCTSYIntegrationTestCallBarringBase::SearchCBStatusListL( CMobilePhoneCBList* aList, 

								RMobilePhone::TMobilePhoneCBCondition aCondition, 

								RMobilePhone::TMobileService aService,

								RMobilePhone::TMobilePhoneCBStatus aStatus )

	{	

	TInt count = aList->Enumerate();

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

		{

		const RMobilePhone::TMobilePhoneCBInfoEntryV1 ele = aList->GetEntryL(i);

		if( ele.iCondition == aCondition && 

			ele.iServiceGroup == aService && 

			ele.iStatus == aStatus )

			{

			return ETrue;

			}		

		}

	DEBUG_PRINTF4( _L("Failed to find CMobilePhoneCBList entry condition=%d service=%d status=%d"), aCondition, aService, aStatus );

	return EFalse;

	}

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

CCTSYIntegrationTestCallBarring0001::CCTSYIntegrationTestCallBarring0001(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestCallBarringBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestCallBarring0001::GetTestStepName());

	}

CCTSYIntegrationTestCallBarring0001::~CCTSYIntegrationTestCallBarring0001()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestCallBarring0001::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/CBAR-0001

 * @SYMTestCaseDesc Activate and deactivate call barring for outgoing voice calls.

 * @SYMTestPriority High

 * @SYMTestActions RMobilePhone::NotifyCallBarringStatusChange, RMobilePhone::SetCallBarringStatus, RCall::Dial, RCall::HangUp

 * @SYMTestExpectedResults Pass - Call barring activated and barred numbers cannot be dialled.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test: Verify call barring status and barred number cannot be dialled.

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

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

	RMobilePhone::TMobilePassword password;

	CheckCBPasswordL( phone, password );

	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of: KCapsNotifyCBStatus | KCapsSetCBStatus | KCapsBarAllOutgoing | KCapsBarOutgoingInternational | KCapsBarOutgoingInternationalExHC

	TUint32 callBarCaps;

	TInt err = phone.GetCallServiceCaps( callBarCaps );

	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCallServiceCaps returned error"));

	CHECK_BITS_SET_L( callBarCaps, 	(RMobilePhone::KCapsNotifyCBStatus | 

									 RMobilePhone::KCapsSetCBStatus | 

									 RMobilePhone::KCapsBarAllOutgoing | 

									 RMobilePhone::KCapsBarOutgoingInternational | 

									 RMobilePhone::KCapsBarOutgoingInternationalExHC) ,

								     KNoUnwantedBits,

								     _L("GetCallServiceCaps returned unexpected bitmap"));	

	// Set the call barring password to a known password using RMobilePhone::SetSSPassword 

	RMobilePhone::TMobilePhonePasswordChangeV2 passwordV2;

	RMobilePhone::TMobilePhonePasswordChangeV2Pckg passwordPkg(passwordV2);

	// NOTE - we don't actually change the password for safety

	passwordV2.iOldPassword = password;

	passwordV2.iNewPassword = password;

	passwordV2.iVerifiedPassword = password;

	TExtEtelRequestStatus reqSetSSPasswordStatus(phone, EMobilePhoneSetSSPassword);

	CleanupStack::PushL(reqSetSSPasswordStatus);

	phone.SetSSPassword(reqSetSSPasswordStatus, passwordPkg, KSsCallBarringAllServices );

	CHECK_EQUALS_L( WaitForRequestWithTimeOut( reqSetSSPasswordStatus, ETimeMedium), KErrNone, 

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

	CHECK_EQUALS_L( reqSetSSPasswordStatus.Int(), KErrNone, _L("RMobilePhone::SetSSPassword returned error"));

	// Get voice line 1. 

	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone, KVoiceLine);

	// Get call 1. 

	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone, KVoiceLine,KCall1 );	

	// Obtain our test call numbers

	TPtrC intNumber; 

	TBool numOK = GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumberInternational, intNumber);

	CHECK_TRUE_L( numOK, _L("Failed to obtain international number for test") );

	TPtrC natNumberWithPrefix; 

	numOK = GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumberIntExHC, natNumberWithPrefix);

	CHECK_TRUE_L( numOK, _L("Failed to obtain prefixed national number for test") );

	TPtrC natNumber; 

	numOK = GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, natNumber);

	CHECK_TRUE_L( numOK, _L("Failed to obtain national number for test") );

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// ===  Activate call barring on voice calls to outgoing international numbers and check 

	// international number cannot be dialled ===

	// Set up the notification request

	TExtEtelRequestStatus cbStatusNotify( phone, EMobilePhoneNotifyCallBarringStatusChange );

	CleanupStack::PushL(cbStatusNotify);

	RMobilePhone::TMobilePhoneCBCondition notifiedCBCondition;

	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

	// Activate call barring using RMobilePhone::SetCallBarringStatus with 

	// aInfo.iAction=EServiceActionActivate, 

	// aInfo.iPassword=correct call barring password, 

	// aInfo.iServiceGroup=EVoiceService and 

	// aCondition=EBarOutgoingInternational

	RMobilePhone::TMobilePhoneCBChangeV1 cbInfo;

	cbInfo.iAction = RMobilePhone::EServiceActionActivate;

	cbInfo.iPassword = password;

	cbInfo.iServiceGroup = RMobilePhone::EVoiceService;

	RMobilePhone::TMobilePhoneCBCondition wantedCBCondition = RMobilePhone::EBarOutgoingInternational;

	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarOutgoingInternational

	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

												cbStatusNotify,

												notifiedCBCondition,

												wantedCBCondition,

												KErrNone );													

	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

					_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

	// Dial an international number. 

	// Check this fails.

	DEBUG_PRINTF2(_L("Barred international - Calling international %S should not be allowed"), &intNumber );

	TExtEtelRequestStatus notifyMobileCallStatusChangeStatus(call1, EMobileCallNotifyMobileCallStatusChange);

	CleanupStack::PushL(notifyMobileCallStatusChangeStatus);

	RMobileCall::TMobileCallStatus mobileCallStatus;

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

	TCoreEtelRequestStatus<RCall> dialStatus(call1, &RCall::DialCancel);

	CleanupStack::PushL(dialStatus);

	call1.Dial(dialStatus, intNumber);

	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDialling ->

	DEBUG_PRINTF1(_L("Checking EStatusDialling") );

	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDialling;

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

																		notifyMobileCallStatusChangeStatus,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDisconnecting.																		

	DEBUG_PRINTF1(_L("Checking EStatusDisconnecting") );	

	expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

																		notifyMobileCallStatusChangeStatus,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusIdle.																		

	DEBUG_PRINTF1(_L("Checking EStatusIdle") );	

	expectedMobileCallStatus = RMobileCall::EStatusIdle;

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

																		notifyMobileCallStatusChangeStatus,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	DEBUG_PRINTF1(_L("Dial status request") );	

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

		_L("RMobileCall::Dial timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrGsmCCNormalUnspecified, 

		_L("RMobileCall::Dial returned error") );

	// Precaution when expected no connection

	DEBUG_PRINTF1(_L("Hanging up...") );	

	call1.HangUp();		

	// ===  Deactivate call barring on voice calls to outgoing international numbers and check 

	// international number can be dialled 

	// ===

	// Deactivate call barring using RMobilePhone::SetCallBarringStatus with 

	// aInfo.iAction=EServiceActionDeactivate, 

	// aInfo.iPassword=correct call barring password, 

	// aInfo.iServiceGroup=EVoiceService 

	// and aCondition=EBarOutgoingInternational 

	cbInfo.iAction = RMobilePhone::EServiceActionDeactivate;

	wantedCBCondition = RMobilePhone::EBarOutgoingInternational;

	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarOutgoingInternational

	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

												cbStatusNotify,

												notifiedCBCondition,

												wantedCBCondition,

												KErrNone );												

	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

					_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

	// Dial an international number that answers. 

	DEBUG_PRINTF2(_L("Calling international %S should be allowed"), &intNumber );

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	call1.Dial(dialStatus, intNumber ); 

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

	expectedMobileCallStatus = RMobileCall::EStatusConnected;

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

														notifyMobileCallStatusChangeStatus, 

														mobileCallStatus, 

														RMobileCall::EStatusConnected, 

														KErrNone );

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

			_L("RMobileCall::Dial timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, 

			_L("RMobileCall::Dial returned an error") );

	// Hang up

	call1.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

	call1.HangUp();

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

	expectedMobileCallStatus = RMobileCall::EStatusIdle;

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

														notifyMobileCallStatusChangeStatus, 

														mobileCallStatus, 

														RMobileCall::EStatusIdle, 

														KErrNone );

	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("Call status is not EStatusIdle") );

	// ===  Activate call barring on voice calls to outgoing international numbers

	// excluding home country and check national number with + prefix can be dialled 

	// but international number in another country cannot be dialled 

	// ===

	// Activate call barring using RMobilePhone::SetCallBarringStatus with 

	// aInfo.iAction=EServiceActionActivate, 

	// aInfo.iPassword=correct call barring password, 

	// aInfo.iServiceGroup=EVoiceService and 

	// aCondition=EBarOutgoingInternationalExHC 

	cbInfo.iAction = RMobilePhone::EServiceActionActivate;

	wantedCBCondition = RMobilePhone::EBarOutgoingInternationalExHC;

	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarOutgoingInternationalExHC

	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

													cbStatusNotify,

													notifiedCBCondition,

													RMobilePhone::EBarOutgoingInternationalExHC,

													KErrNone );

	// Dial a national number that answers specifying the number using + prefix. 

	DEBUG_PRINTF1(_L("Barred international ExHC - Calling national with + prefix"));

	call1.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

	call1.Dial(dialStatus, natNumberWithPrefix ); 

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

														notifyMobileCallStatusChangeStatus, 

														mobileCallStatus, 

														RMobileCall::EStatusConnected, KErrNone );

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

			_L("RMobileCall::Dial timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, 

			_L("RMobileCall::Dial returned an error") );

	// Hang up. 

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

	call1.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

	call1.HangUp();

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

														notifyMobileCallStatusChangeStatus, 

														mobileCallStatus, 

														RMobileCall::EStatusIdle, 

														KErrNone );

	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("RMobileCall::NotifyMobileCallStatusChange did not complete with EStatusIdle") );

	// Dial an international number in another country. 

	// Check this fails.

	DEBUG_PRINTF1(_L("Barred international ExHC- Calling international"));

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	call1.Dial(dialStatus, intNumber); 

	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDialling ->

	DEBUG_PRINTF1(_L("Checking EStatusDialling") );

	expectedMobileCallStatus = RMobileCall::EStatusDialling;

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

																		notifyMobileCallStatusChangeStatus,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusConnecting ->

	DEBUG_PRINTF1(_L("Checking EStatusConnecting") );	

	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

																		notifyMobileCallStatusChangeStatus,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDisconnecting.																		

	DEBUG_PRINTF1(_L("Checking EStatusDisconnecting") );	

	expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

																		notifyMobileCallStatusChangeStatus,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusIdle.																		

	DEBUG_PRINTF1(_L("Checking EStatusIdle") );	

	expectedMobileCallStatus = RMobileCall::EStatusIdle;

	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

																		notifyMobileCallStatusChangeStatus,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

		_L("RMobileCall::Dial timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrGsmCCNormalUnspecified, 

		_L("RMobileCall::Dial returned error") );

	// Precaution when expected no connection

	call1.HangUp();		

	// ===  Deactivate call barring on voice calls to outgoing international numbers excluding home country