// 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 PhoneSecurity in the Common TSY.

// 

//

/**

 @file 

*/

#include "cctsyphonesecurityfu.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 <ctsy/serviceapi/mmtsy_defaults.h>

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetLockInfo0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetLockInfo0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetLockInfo0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetLockInfo0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestClearBlacklist0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestSetLockSetting0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestSetLockSetting0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestSetLockSetting0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestSetLockSetting0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestSetLockSetting0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCaps0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestAbortSecurityCode0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestAbortSecurityCode0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestAbortSecurityCode0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestAbortSecurityCode0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestChangeSecurityCode0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestChangeSecurityCode0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestChangeSecurityCode0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestChangeSecurityCode0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0012L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0013L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestVerifySecurityCode0014L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityEvent0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifyLockInfoChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifyLockInfoChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifyLockInfoChange0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifyLockInfoChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCodeInfo0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCodeInfo0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCodeInfo0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCodeInfo0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCodeInfo0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCodeInfo0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestGetSecurityCodeInfo0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityCodeInfoChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityCodeInfoChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityCodeInfoChange0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityCodeInfoChange0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityCapsChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityCapsChange0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneSecurityFU, TestNotifySecurityCapsChange0004L);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-PSEC-MGLI-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetLockInfo

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::GetLockInfo

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestGetLockInfo0001L()

	{

	OpenEtelServerL();

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

	OpenPhoneL();

	RBuf8 dataExpect;

	CleanupClosePushL(dataExpect);

	RBuf8 dataComplete;

	CleanupClosePushL(dataComplete);

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

	// TEST A: failure to dispatch request to LTSY

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

	RMobilePhone::TMobilePhoneLock currentLock = RMobilePhone::ELockICC;

	TMockLtsyData1<RMobilePhone::TMobilePhoneLock> phoneLockType(currentLock);

	phoneLockType.SerialiseL(dataExpect);

	iMockLTSY.ExpectL(EMobilePhoneGetLockInfo, dataExpect, KErrNotSupported);

	TRequestStatus reqStatus;

	RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

	RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPckg(lockInfo);

	iPhone.GetLockInfo(reqStatus, currentLock, lockInfoPckg);

    User::WaitForRequest(reqStatus);

   	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

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

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

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

	iMockLTSY.ExpectL(EMobilePhoneGetLockInfo, dataExpect);

	RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;

	RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;

    TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> phoneLockData(lockStatus, lockSetting);

	phoneLockData.SerialiseL(dataComplete);

	iMockLTSY.CompleteL(EMobilePhoneGetLockInfo, KErrGeneral , dataComplete);

	iPhone.GetLockInfo(reqStatus, currentLock, lockInfoPckg);

	User::WaitForRequest(reqStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

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

	// TEST C: Successful completion request of

	// RMobilePhone::GetLockInfo when result is not cached.

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

	iMockLTSY.ExpectL(EMobilePhoneGetLockInfo, dataExpect);

	iMockLTSY.CompleteL(EMobilePhoneGetLockInfo, KErrNone, dataComplete);

	iPhone.GetLockInfo(reqStatus, currentLock, lockInfoPckg);

    User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNone, reqStatus.Int());

	ASSERT_EQUALS(lockInfo.iSetting, lockSetting);

	ASSERT_EQUALS(lockInfo.iStatus, lockStatus);	

   	AssertMockLtsyStatusL();	

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

	// TEST E:

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

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(EMobilePhoneGetLockInfo, KErrNone, dataComplete);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	CleanupStack::PopAndDestroy(3); // dataComplete, dataExpect, this

	}

/**

@SYMTestCaseID BA-CTSY-PSEC-MGLI-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::GetLockInfo

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RMobilePhone::GetLockInfo

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestGetLockInfo0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	RBuf8 data;

	CleanupClosePushL(data);

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

	// Test cancelling of RMobilePhone::GetLockInfo

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

	// Expect request in LTSY

	RMobilePhone::TMobilePhoneLock currentLock = RMobilePhone::ELockICC;

	TMockLtsyData1<RMobilePhone::TMobilePhoneLock> phoneLockType(currentLock);

	phoneLockType.SerialiseL(data);

	iMockLTSY.ExpectL(EMobilePhoneGetLockInfo, data);

	// Complete request after a delay

	RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;

	RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;

    TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> phoneLockData(lockStatus, lockSetting);

	data.Close();

	phoneLockData.SerialiseL(data);

	iMockLTSY.CompleteL(EMobilePhoneGetLockInfo, KErrNone , data, 20);

	// Make request and cancel it

	TRequestStatus reqStatus;

	RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

	RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPckg(lockInfo);

	iPhone.GetLockInfo(reqStatus, currentLock, lockInfoPckg);

	iPhone.CancelAsyncRequest(EMobilePhoneGetLockInfo);

	User::WaitForRequest(reqStatus);

	// Check status is KErrCancel

	ASSERT_EQUALS(KErrCancel,reqStatus.Int());

	// Wait for completion of iMockLTSY.NotifyTerminated

	User::WaitForRequest(mockLtsyStatus);

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

	}

/**

@SYMTestCaseID BA-CTSY-PSEC-MGLI-0003

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetLockInfo with bad parameter data

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::GetLockInfo with bad parameter data

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestGetLockInfo0003L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

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

	// Test B: Test passing wrong descriptor size to parameter in

	// RMobilePhone::GetLockInfo

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

	// CTSY should return an error straight away

	TTestMultimodeType badType(KETelExtMultimodeV1);

	TTestMultimodeTypePckg badTypePckg(badType);

	TRequestStatus reqStatus;

	iPhone.GetLockInfo(reqStatus, RMobilePhone::ELockICC, badTypePckg);

    User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrArgument, reqStatus.Int());

   	AssertMockLtsyStatusL();

	// Done !

	CleanupStack::PopAndDestroy(this); // this

	}

/**

@SYMTestCaseID BA-CTSY-PSEC-MGLI-0005

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetLockInfo with timeout

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::GetLockInfo and tests for timeout

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestGetLockInfo0005L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

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

	// Test A: Test timeout of RMobilePhone::GetLockInfo

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

	// Expect request in LTSY

	RMobilePhone::TMobilePhoneLock currentLock = RMobilePhone::ELockICC;

	TMockLtsyData1<RMobilePhone::TMobilePhoneLock> phoneLockType(currentLock);

	phoneLockType.SerialiseL(data);

	iMockLTSY.ExpectL(EMobilePhoneGetLockInfo, data);

	// Make request and wait for it to timeout

	TRequestStatus reqStatus;

	RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

	RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPckg(lockInfo);

	iPhone.GetLockInfo(reqStatus, currentLock, lockInfoPckg);

	User::WaitForRequest(reqStatus);

	// Check status is KErrTimedOut

	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int())

	// Done !

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

	}

/**

@SYMTestCaseID BA-CTSY-PSEC-MCB-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobilePhone::ClearBlacklist

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::ClearBlacklist

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestClearBlacklist0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus reqStatus;

	iPhone.ClearBlacklist(reqStatus);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())

	// Test API is not supported

	AssertMockLtsyStatusL();

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

	}

/**

@SYMTestCaseID BA-CTSY-PSEC-MSLS-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetLockSetting

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::SetLockSetting

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestSetLockSetting0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RBuf8 dataComplete;

	CleanupClosePushL(dataComplete);

	TRequestStatus status;

	// data for ExpectL for test B

	RMobilePhone::TMobilePhoneLockStatus lockStatusB = RMobilePhone::EStatusLocked;

	RMobilePhone::TMobilePhoneLock lockB = RMobilePhone::ELockPhoneDevice;

	RMobilePhone::TMobilePhoneLockSetting lockSettingB = RMobilePhone::ELockSetEnabled;	

	// data for CompleteL

	TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> 

															lockStatusDataB(lockStatusB,lockSettingB);

	lockStatusDataB.SerialiseL(dataComplete);

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

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

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

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

	iPhone.SetLockSetting(status, lockB, lockSettingB);	

	iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrGeneral, dataComplete);

	User::WaitForRequest(status);

	ASSERT_EQUALS(KErrGeneral, status.Int());

	AssertMockLtsyStatusL();

	// data for ExpectL

	TLockSettingPassword lockSettingPassword;

	lockSettingPassword.iPassword.Copy(KNullDesC);

	RMobilePhone::TMobilePhoneLock& lock( lockSettingPassword.iLock );

	RMobilePhone::TMobilePhoneLockSetting& lockSetting( lockSettingPassword.iSetting );

	lock        = RMobilePhone::ELockHiddenKey;//ELockUSimApp;

	lockSetting = RMobilePhone::ELockSetEnabled;	

	TMockLtsyData1<TLockSettingPassword> phoneLockData(lockSettingPassword);

	phoneLockData.SerialiseL(data);

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

	// TEST E: Unsolicited completion of RMobilePhone::SetLockSetting

	// from LTSY.

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

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

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

	// TEST C: Successful completion request of

	// RMobilePhone::SetLockSetting when result is not cached.

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

	iMockLTSY.ExpectL(EMobilePhoneSetLockSetting, data);

	iPhone.SetLockSetting(status, lock, lockSetting);

	iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);

	User::WaitForRequest(status);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, status.Int());	

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

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

	// TEST E2: Unsolicited completion of RMobilePhone::SetLockSetting

	// from LTSY.

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

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	

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

	// TEST A: failure to dispatch request to LTSY

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

	iMockLTSY.ExpectL(EMobilePhoneSetLockSetting, data);		

	iPhone.SetLockSetting(status, lock, lockSetting);

	iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);

	User::WaitForRequest(status);

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

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, status.Int());

	AssertMockLtsyStatusL();	

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

	}

/**

@SYMTestCaseID BA-CTSY-PSEC-MSLS-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::SetLockSetting

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RMobilePhone::SetLockSetting

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestSetLockSetting0002L()

	{

// This test should test cancellation of SetLockSetting

// If this API does not have a cancel, the test step should be completely removed.

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	RBuf8 data;

	CleanupClosePushL(data);

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

	// Test cancelling of RMobilePhone::SetLockSetting

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

 	RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;

	RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockPhoneDevice;

	RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;

 	TMockLtsyData2 <RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> ltsyData(lockStatus, lockSetting);

	ltsyData.SerialiseL(data);	

	TRequestStatus requestStatus;

	//send request

	iPhone.SetLockSetting(requestStatus, lock, lockSetting);	

	// send canceling...

	iPhone.CancelAsyncRequest(EMobilePhoneSetLockSetting);

	//send completion

	iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, data);

	// wait for completion

	User::WaitForRequest(mockLtsyStatus);

	// wait for NotifyStatusChange

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrCancel, requestStatus.Int());

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

	}

/**

@SYMTestCaseID BA-CTSY-PSEC-MSLS-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::SetLockSetting

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RMobilePhone::SetLockSetting

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPhoneSecurityFU::TestSetLockSetting0004L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();