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

// 

//

/**

 @internalTechnology

*/

#include "cctsyintegrationtestcallemergency.h"

#include "cctsyinidata.h"

const RMobilePhone::TMobilePassword KAltWrongPin = _L("abcd");

_LIT(KEmergencyNumber112,"112");

_LIT(KEmergencyNumber999,"999");

_LIT(KEmergencyNumber110,"110");

_LIT(KEmergencyNumber118,"118");

_LIT(KEmergencyNumber119,"119");

_LIT(KEmergencyNumber08,"08");

_LIT(KEmergencyNumber000,"000");

CCTSYIntegrationTestCallEmergencyBase::CCTSYIntegrationTestCallEmergencyBase(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iNetworkTestHelper(*this), iPhoneTestHelper(*this), iCallControlTestHelper(*this)

/**

 * Constructor

 */

	{

	}

CCTSYIntegrationTestCallEmergencyBase::~CCTSYIntegrationTestCallEmergencyBase()

/*

 * Destructor

 */

	{

	}

void CCTSYIntegrationTestCallEmergencyBase::MakeEmergencyCallL(RMobileCall& aCall, const TDesC& aNumber)

/**

 * Dials emergency call, checks it is successful, check the status of the call and hangs up

 * @param aCall Handle to RMobileCall object

 * @param aNumber number to be dialled.

 * 

 * @return void

 */

    {

	DEBUG_PRINTF2(_L("Dialing to emergency number: %S"),&aNumber);

	// Post notifier for RMobileCall::NotifyMobileCallStatusChange

	RMobileCall::TMobileCallStatus mobileCallStatus;

	TExtEtelRequestStatus notifyCallStatusChange(aCall, EMobileCallNotifyMobileCallStatusChange);

	CleanupStack::PushL(notifyCallStatusChange);

	aCall.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

	// Dial RMobileCall::DialEmergencyCall with aNumber 

	TExtEtelRequestStatus dialStatus(aCall, EMobileCallDialEmergencyCall);

	CleanupStack::PushL(dialStatus);

	aCall.DialEmergencyCall(dialStatus, aNumber);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeVeryLong), KErrNone,  _L("RMobileCall::DialEmergencyCall timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::DialEmergencyCall returned an error"));

	// ===  Check mobile call status ===

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDialling;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

																		notifyCallStatusChange,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	// Repost notifier

	aCall.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

																		notifyCallStatusChange,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);

	// Repost notifier

	aCall.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

	expectedMobileCallStatus = RMobileCall::EStatusConnected;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

																		notifyCallStatusChange,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);																	

	// Check RMobileCall::GetMobileCallStatus returns status of EStatusConnected.

	ASSERT_EQUALS(aCall.GetMobileCallStatus(mobileCallStatus), KErrNone, _L("RMobileCall::GetMobileCallStatus returned an error"));

	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusConnected, _L("RMobileCall::GetMobileCallStatus did not return EStatusIdle"));

	// Hang up. 

	TCoreEtelRequestStatus<RMobileCall> hangUpStatus (aCall, &RCall::HangUpCancel);	

	CleanupStack::PushL(hangUpStatus);

	aCall.HangUp(hangUpStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(hangUpStatus, ETimeLong), KErrNone, _L("RCall::HangUp timed-out"));

	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RCall::HangUp returned an error"));	

	aCall.NotifyMobileCallStatusChange(notifyCallStatusChange, mobileCallStatus);

	expectedMobileCallStatus = RMobileCall::EStatusIdle;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

																		notifyCallStatusChange,

																		mobileCallStatus,

																		expectedMobileCallStatus,

																		KErrNone);																	

	// Pop

	// notifyCallStatusChange

	// dialStatus

	// hangUpStatus	

	CleanupStack::PopAndDestroy(3, &notifyCallStatusChange);

}

CCTSYIntegrationTestCallEmergency0001::CCTSYIntegrationTestCallEmergency0001(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestCallEmergencyBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestCallEmergency0001::GetTestStepName());

	}

CCTSYIntegrationTestCallEmergency0001::~CCTSYIntegrationTestCallEmergency0001()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestCallEmergency0001::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/CEMG-0001

 * @SYMTestCaseDesc Dial an emergency call (with international emergency number) using SIM/USIM with no emergency numbers stored on it.

 * @SYMTestPriority High

 * @SYMTestActions RMobilePhone::VerifySecurityCode, RMobilePhone::NotifySecurityEvent, RMobilePhone::SetFdnSetting, RCall::HangUp, RMobileCall::GetMobileCallStatus, RMobileCall::DialEmergencyCall, RMobileCall::GetMobileCallInfo

 * @SYMTestExpectedResults Pass - Call to international emergency numbers can be made.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies simulated/manual

 *

 * Reason for test: Verify national and international emergency numbers can be dialled with and without FDN active including when phone is in forbidden PLMN.

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

    // Check that the phone is registered with the network simulator. 

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

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

	iNetworkTestHelper.CheckPhoneConnectedToAniteL(phone);

	// Ensure RMobilePhone::GetSecurityCaps returns caps in set of KCapsAccessPin2 

	TUint32 securityCaps;

	CHECK_EQUALS_L(phone.GetSecurityCaps(securityCaps), KErrNone,_L("RMobilePhone::GetSecurityCaps returned with an error"));

	CHECK_BITS_SET_L(securityCaps,RMobilePhone::KCapsAccessPin2 ,KNoUnwantedBits, _L("RMobilePhone::GetSecurityCaps did not return KCapsAccessPin2 bits"));

    // get network operator information

	const TDesC* networkSection = NULL;

	iNetworkTestHelper.GetNetworkPasswordsSectionL(phone, networkSection);

	// Get the password from the ini file

	TPtrC pin2; 

	CHECK_TRUE_L(GetStringFromConfig(*networkSection, KIniPin2, pin2) != EFalse, _L("GetStringFromConfig returned with an error"));

	// Lock PIN2 with RMobilePhone::SetLockSetting with aLock=ELockPin2, aSetting=ELockSetEnabled

	// $CTSYProblem RMobilePhone::SetLockSetting returns KErrNotSupported from LTSY.

	iPhoneTestHelper.ChangePhoneLockSettingL(phone, RMobilePhone::ELockPin2, RMobilePhone::ELockSetEnabled, pin2, KErrNotSupported);

	// Ensure RMobilePhone::GetLockInfo aLock=ELockPin2 returns TMobilePhoneLockInfoV1::iStatus=EStatusLocked and TMobilePhoneLockInfoV1::iSetting = ELockSetEnabled 

	RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

	RMobilePhone::TMobilePhoneLockInfoV1Pckg infoPckg(lockInfo);

	TExtEtelRequestStatus getLockInfoStatus(phone, EMobilePhoneGetLockInfo);

	CleanupStack::PushL(getLockInfoStatus);

	phone.GetLockInfo(getLockInfoStatus, RMobilePhone::ELockPin2, infoPckg);

	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getLockInfoStatus, ETimeLong), KErrNone, _L("RMobilePhone::GetLockInfo timed out"));

	CHECK_EQUALS_L(getLockInfoStatus.Int(), KErrNone, _L("RMobilePhone::GetLockInfo returned an error"));

	CHECK_EQUALS_L(lockInfo.iStatus, RMobilePhone::EStatusLocked, _L("RMobilePhone::GetLockInfo did not returned iStatus = RMobilePhone::EStatusLocked"));

	CHECK_EQUALS_L(lockInfo.iSetting, RMobilePhone::ELockSetEnabled, _L("RMobilePhone::GetLockInfo did not returned iSetting = RMobilePhone::ELockSetEnabled"));

	// Ensure the FDN is deactivated (RMobilePhone::GetFdnStatus returns EFdnNotActive) 

	RMobilePhone::TMobilePassword pin2Password;

	pin2Password.Copy(pin2);

	RMobilePhone::TMobilePhoneFdnStatus fdnStatus;

	CHECK_EQUALS_L(phone.GetFdnStatus(fdnStatus), KErrNone, _L("RMobilePhone::GetFdnStatus returned an error"));

    if(fdnStatus != RMobilePhone::EFdnNotActive)

        {

        CHECK_EQUALS_L(iPhoneTestHelper.SetPhoneFdnSettingL(phone, pin2Password, RMobilePhone::EFdnSetOff), KErrNone,_L("RMobilePhone::SetFdnSetting failed"));

        CHECK_EQUALS_L(phone.GetFdnStatus(fdnStatus), KErrNone, _L("RMobilePhone::GetFdnStatus returned an error"));

        }

	CHECK_EQUALS_L(fdnStatus, RMobilePhone::EFdnNotActive, _L("RMobilePhone::GetFdnStatus did not return EfdnNotActive."));

    // Get server

    RTelServer& telServer = iEtelSessionMgr.GetServerL(KMainServer);

	// Get voice line 1. 

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

	// Get call 1. 

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

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// Dial an emergency call 112

    DoTest0001L(phone, mobileCall, KEmergencyNumber112, pin2Password);

	// Repeat whole test dialling 999 instead of 112.

    DoTest0001L(phone, mobileCall, KEmergencyNumber999, pin2Password);

	// Repeat whole test with both numbers with simulator simulating phone not camped on suitable cell (forbidden PLMN). 

	TExtEtelRequestStatus reqStatus(phone, EMobilePhoneNotifyNetworkRegistrationStatusChange );

	CleanupStack::PushL(reqStatus);

	RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus;

	phone.NotifyNetworkRegistrationStatusChange(reqStatus, registrationStatus);

	DisplayUserInteractionPromptL(_L("Make sure phone is not camped on suitable cell (forbidden PLMN)"), ETimeLong);

	TInt err = WaitForRequestWithTimeOut(reqStatus,ETimeVeryLong);

	while (	(err == KErrNone) && (reqStatus.Int() == KErrNone) && (registrationStatus == RMobilePhone::ENotRegisteredSearching ) )

		{

		phone.NotifyNetworkRegistrationStatusChange(reqStatus, registrationStatus);

		err = WaitForRequestWithTimeOut(reqStatus,ETimeVeryLong);

		}

	DEBUG_PRINTF2(_L(" Network  registration status  = %d"), registrationStatus);

    DoTest0001L(phone, mobileCall, KEmergencyNumber112, pin2Password);

    DoTest0001L(phone, mobileCall, KEmergencyNumber999, pin2Password);

	//

	// TEST END

	//

    StartCleanup();

	// Pop:

	//	reqStatus

	//	getLockInfoStatus

	CleanupStack::PopAndDestroy(2,&getLockInfoStatus);

   return TestStepResult();

    }

void CCTSYIntegrationTestCallEmergency0001::DoTest0001L(RMobilePhone &aPhone,

                                                        RMobileCall& aCall,

                                                        const TDesC& aNumber,

                                                        RMobilePhone::TMobilePassword& aPIN2Password)

/**

 * Function for dialling an emergency call. This is a helper method for repeating emergency calls in test 0001.

 * 

 * @param aPhone a reference to RMobilePhone object

 * @param aCall a reference to RMobileCall object

 * @param aNumber TDesC holding the emergecy number

 * @param aPIN2Password TMobilePassword holding the PIN2 password

 * @return void

 */

	{

	// Set priority client with RTelServer::SetPriorityClientV2

	// $CTSYProblem Can't set client priority, ETEL returns KErrPermissionDenied  

	// Post Notifier for RMobileCall::NotifyMobileCallStatusChange

	TExtEtelRequestStatus notifyMobileCallStatusChangeStatus(aCall, EMobileCallNotifyMobileCallStatusChange);

	CleanupStack::PushL(notifyMobileCallStatusChangeStatus);

	RMobileCall::TMobileCallStatus mobileCallStatus;

	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	// Dial RMobileCall::DialEmergencyCall with aNumber 

	DEBUG_PRINTF2(_L("Board Now Dialling: %S"),&aNumber);

	TExtEtelRequestStatus dialStatus(aCall, EMobileCallDialEmergencyCall);

	CleanupStack::PushL(dialStatus);

	aCall.DialEmergencyCall(dialStatus, aNumber); 

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::DialEmergencyCall timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::DialEmergencyCall returned with an error"));

	// ===  Check mobile call status ===

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDialling;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

															notifyMobileCallStatusChangeStatus,

															mobileCallStatus,

															expectedMobileCallStatus,

															KErrNone);

	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

															notifyMobileCallStatusChangeStatus,

															mobileCallStatus,

															expectedMobileCallStatus,

															KErrNone);

	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	expectedMobileCallStatus = RMobileCall::EStatusConnected;															

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

															notifyMobileCallStatusChangeStatus,

															mobileCallStatus,

															expectedMobileCallStatus,

															KErrNone);

	// Check RMobileCall::GetMobileCallStatus returns status of EStatusConnected.

	ASSERT_EQUALS(aCall.GetMobileCallStatus(mobileCallStatus), KErrNone,  _L("RMobileCall::GetMobileStatus returned an error."));

	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusConnected, _L("RMobileCall::GetMobileStatus did not return EStatusConnected."));

	// ===  Check call info ===

	// Check RMobileCall::GetMobileCallInfo returns valid call name.

	RMobileCall::TMobileCallInfoV1 mobileCallInfo;

	RMobileCall::TMobileCallInfoV1Pckg mobileCallInfoPckg(mobileCallInfo);

	ASSERT_EQUALS(aCall.GetMobileCallInfo(mobileCallInfoPckg), KErrNone, _L("RMobileCall::GetMobileCallInfo returned an error"));

	ASSERT_TRUE(mobileCallInfo.iCallName.Length() > 0, _L("RMobileCall::GetMobileCallInfo returned an invalid call name"));

	// Check RMobileCall::GetMobileCallInfo returns valid line name.

	ASSERT_TRUE(mobileCallInfo.iLineName.Length() > 0, _L("RMobileCall::GetMobileCallInfo returned an invalid line name"));

	// Check RMobileCall::GetMobileCallInfo returns iDialledParty = 112

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

	ASSERT_EQUALS_DES16(mobileCallInfo.iDialledParty.iTelNumber, aNumber, _L("RMobileCall::GetMobileCallInfo returned an invalid number"));

	// Check RMobileCall::GetMobileCallInfo returns iEmergency = ETrue

	ASSERT_TRUE(mobileCallInfo.iEmergency, _L("RMobileCall::GetMobileCallInfo did not return ETrue for iEmergency"));

	// Hang up with RCall::HangUp 

	TCoreEtelRequestStatus<RMobileCall> hangUpStatus (aCall, &RCall::HangUpCancel);	

	CleanupStack::PushL(hangUpStatus);

	aCall.HangUp(hangUpStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(hangUpStatus, ETimeLong), KErrNone, _L("RCall::HangUp timed-out"));

	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RCall::HangUp returned an error"));	

	// ===  Activate the FDN ===

	// Call RMobilePhone::SetFdnSetting with RMobilePhone::EFdnSetOn 

    TInt err = iPhoneTestHelper.SetPhoneFdnSettingL(aPhone, aPIN2Password, RMobilePhone::EFdnSetOn);

	// Check RMobilePhone::SetFdnSetting completes with KErrNone

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

    // Repost notifier for RMobileCall::NotifyMobileCallStatusChange

	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	// Dial RMobileCall::DialEmergencyCall with aNumber=112 

	aCall.DialEmergencyCall(dialStatus, aNumber); 

	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::DialEmergencyCall timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::DialEmergencyCall returned with an error"));

	// ===  Check mobile call status ===

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

	expectedMobileCallStatus = RMobileCall::EStatusDialling;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

															notifyMobileCallStatusChangeStatus,

															mobileCallStatus,

															expectedMobileCallStatus,

															KErrNone);

	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

															notifyMobileCallStatusChangeStatus,

															mobileCallStatus,

															expectedMobileCallStatus,

															KErrNone);

	aCall.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

	expectedMobileCallStatus = RMobileCall::EStatusConnected;															

	iCallControlTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(aCall,

															notifyMobileCallStatusChangeStatus,

															mobileCallStatus,

															expectedMobileCallStatus,

															KErrNone);

	// Check RMobileCall::GetMobileCallStatus returns status of EStatusConnected.

	ASSERT_EQUALS(aCall.GetMobileCallStatus(mobileCallStatus), KErrNone,  _L("RMobileCall::GetMobileStatus returned an error."));

	ASSERT_EQUALS(mobileCallStatus, RMobileCall::EStatusConnected, _L("RMobileCall::GetMobileStatus did not return status EStatusConnected."));

	// Check RMobileCall::GetMobileCallInfo returns iValid of 0.

	ASSERT_EQUALS(aCall.GetMobileCallInfo(mobileCallInfoPckg), KErrNone, _L("RMobileCall::GetMobileCallInfo returned an error"));

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

	ASSERT_TRUE(mobileCallInfo.iValid == 0, _L("RMobileCall::GetMobileCallInfo returned unexpected flags in iValid"));

	// Check RMobileCall::GetMobileCallInfo returns valid call name.

	ASSERT_TRUE(mobileCallInfo.iCallName.Length() > 0, _L("RMobileCall::GetMobileCallInfo returned an invalid call name"));

	// Check RMobileCall::GetMobileCallInfo returns valid line name.

	ASSERT_TRUE(mobileCallInfo.iLineName.Length() > 0, _L("RMobileCall::GetMobileCallInfo returned an invalid line name"));

	// Check RMobileCall::GetMobileCallInfo returns iDialledParty = 112

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

	ASSERT_EQUALS_DES16(mobileCallInfo.iDialledParty.iTelNumber, aNumber, _L("RMobileCall::GetMobileCallInfo returned an invalid number"));

	// Check RMobileCall::GetMobileCallInfo returns iEmergency = ETrue

	ASSERT_TRUE(mobileCallInfo.iEmergency, _L("RMobileCall::GetMobileCallInfo did not return ETrue for iEmergency"));

	// Hang up with RCall::HangUp 

	aCall.HangUp(hangUpStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(hangUpStatus, ETimeLong), KErrNone, _L("RCall::HangUp timed-out"));

	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RCall::HangUp returned an error"));	

	// Pop

    // notifyMobileCallStatusChangeStatus

    // dialStatus

    // hangUpStatus

   CleanupStack::PopAndDestroy(3, &notifyMobileCallStatusChangeStatus);

	}

TPtrC CCTSYIntegrationTestCallEmergency0001::GetTestStepName()

/**

 * @return The test step name.

 */

	{

	return _L("CCTSYIntegrationTestCallEmergency0001");

	}

CCTSYIntegrationTestCallEmergency0002::CCTSYIntegrationTestCallEmergency0002(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestCallEmergencyBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestCallEmergency0002::GetTestStepName());

	}

CCTSYIntegrationTestCallEmergency0002::~CCTSYIntegrationTestCallEmergency0002()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestCallEmergency0002::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/CEMG-0002

 * @SYMTestCaseDesc Dial an emergency call using SIM/USIM with no emergency numbers stored on it.

 * @SYMTestPriority High

 * @SYMTestActions RMobilePhone::VerifySecurityCode, RMobilePhone::NotifySecurityEvent, RMobilePhone::SetFdnSetting, RCall::HangUp, RMobileCall::GetMobileCallStatus, RMobileCall::DialEmergencyCall, RTelServer::SetPriorityClient

 * @SYMTestExpectedResults Pass - Emergency call can be made to only when FDN is not active and phone is camped on a valid cell. 

 * @SYMTestType CIT

 * @SYMTestCaseDependencies simulated/manual

 *

 * Reason for test: Verify numbers can be dialled when FDN is inactive but not when active.

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	// Ensure RMobilePhone::GetSecurityCaps returns caps in set of KCapsAccessPin2 

	// Lock PIN2 with RMobilePhone::SetLockSetting with aLock=ELockPin2, aSetting=ELockSetEnabled 

	// Enusre RMobilePhone::GetLockInfo aLock=ELockPin2 returns TMobilePhoneLockInfoV1::iStatus=EStatusLocked and TMobilePhoneLockInfoV1::iSetting = ELockSetEnabled 

	// Ensure the FDN is deactivated (RMobilePhone::GetFdnStatus returns EFdnNotActive) 

	// Get voice line 1. 

	// Get call 1. 

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// Dial RMobileCall::DialEmergencyCall with aNumber=08 

	// Simulator should let call ring then answer the call 

	// ===  Check mobile call status ===

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.

	// Check RMobileCall::GetMobileCallStatus returns status of EStatusConnected.

	// Hang up with RCall::HangUp 

	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle

	// ===  Activate the FDN ===