--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/component/src/cctsyphonesecurityfu.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,4274 @@
+// 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();
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ RBuf8 dataExpect2;
+ CleanupClosePushL(dataExpect2);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ // 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);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::SetLockSetting
+ //-------------------------------------------------------------------------
+ // initialize data for first mobile phone's SetLockSetting
+ TLockSettingPassword lockSettingPassword;
+ lockSettingPassword.iPassword.Copy(KNullDesC);
+ RMobilePhone::TMobilePhoneLock& lock( lockSettingPassword.iLock );
+ RMobilePhone::TMobilePhoneLockSetting& lockSetting( lockSettingPassword.iSetting );
+ lock = RMobilePhone::ELockHiddenKey;
+ lockSetting = RMobilePhone::ELockSetEnabled;
+ TMockLtsyData1<TLockSettingPassword> expData(lockSettingPassword);
+ expData.SerialiseL(dataExpect);
+
+ // initialize data for second mobile phone's SetLockSetting
+ TLockSettingPassword lockSettingPassword2;
+ lockSettingPassword2.iPassword.Copy(KNullDesC);
+ RMobilePhone::TMobilePhoneLock& lock2( lockSettingPassword2.iLock );
+ RMobilePhone::TMobilePhoneLockSetting& lockSetting2( lockSettingPassword2.iSetting );
+ lock2 = RMobilePhone::ELockUSimApp;
+ lockSetting2 = RMobilePhone::ELockSetDisabled;
+ TMockLtsyData1<TLockSettingPassword> expData2(lockSettingPassword2);
+ expData2.SerialiseL(dataExpect2);
+
+ // data for complete
+ RMobilePhone::TMobilePhoneLockStatus complete_lockStatus = RMobilePhone::EStatusLocked;
+ RMobilePhone::TMobilePhoneLockSetting complete_lockSetting = RMobilePhone::ELockSetEnabled;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting>
+ lockStatusData(complete_lockStatus,complete_lockSetting);
+ lockStatusData.SerialiseL(dataComplete);
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+
+ // send first request
+ iMockLTSY.ExpectL(EMobilePhoneSetLockSetting, dataExpect);
+ iPhone.SetLockSetting(requestStatus, lock, lockSetting);
+
+ // send second request
+ phone2.SetLockSetting(requestStatus2, lock2, lockSetting2);
+
+ // send completion for first phone SetlockSetting
+ iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);
+
+ // wait for first phone SetLockSetting
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ // wait for second phone SetLockSetting.
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
+
+ AssertMockLtsyStatusL();
+ // Done !
+ CleanupStack::PopAndDestroy(6, this); // this ...
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MSLS-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetLockSetting with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::SetLockSetting and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestSetLockSetting0005L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test timeout of RMobilePhone::SetLockSetting
+ //-------------------------------------------------------------------------
+ RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;
+ TLockSettingPassword lockSettingPassword;
+ lockSettingPassword.iPassword.Copy(KNullDesC);
+ RMobilePhone::TMobilePhoneLock& lock( lockSettingPassword.iLock );
+ RMobilePhone::TMobilePhoneLockSetting& lockSetting( lockSettingPassword.iSetting );
+ lock = RMobilePhone::ELockPhoneDevice;
+ lockSetting = RMobilePhone::ELockSetEnabled;
+ TMockLtsyData1<TLockSettingPassword> expData(lockSettingPassword);
+ expData.SerialiseL(dataExpect);
+
+ TMockLtsyData2 <RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> ltsyData(lockStatus, lockSetting);
+ ltsyData.SerialiseL(data);
+
+ TRequestStatus requestStatus;
+
+ iMockLTSY.ExpectL(EMobilePhoneSetLockSetting, dataExpect);
+
+ iPhone.SetLockSetting(requestStatus, lock, lockSetting);
+
+ // wait for first phone SetLockSetting
+ ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 70303);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ // Done !
+ CleanupStack::PopAndDestroy(3, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MSLS-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetLockSetting
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::SetLockSetting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestSetLockSetting0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+
+ //-------------------------------------------------------------------------
+ // TEST for case RMobilePhone::ELockICC:
+ //-------------------------------------------------------------------------
+ // data for ExpectL
+ RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;
+ TLockSettingPassword lockSettingPassword;
+ lockSettingPassword.iPassword.Copy(KNullDesC);
+ RMobilePhone::TMobilePhoneLock& lock( lockSettingPassword.iLock );
+ RMobilePhone::TMobilePhoneLockSetting& lockSetting( lockSettingPassword.iSetting );
+ lock = RMobilePhone::ELockICC;
+ lockSetting = RMobilePhone::ELockSetEnabled;
+ TMockLtsyData1<TLockSettingPassword> phoneLockData(lockSettingPassword);
+ phoneLockData.SerialiseL(data);
+
+ // data for CompleteL
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting>
+ lockStatusData(lockStatus,lockSetting);
+ lockStatusData.SerialiseL(dataComplete);
+ TRequestStatus status;
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ // send completion
+ iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNone, status.Int());
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST for case RMobilePhone::ELockPin2
+ //-------------------------------------------------------------------------
+ // data for ExpectL
+ lockStatus = RMobilePhone::EStatusLocked;
+ lock = RMobilePhone::ELockPin2;
+ lockSetting = RMobilePhone::ELockSetEnabled;
+ data.Close();
+ phoneLockData.SerialiseL(data);
+
+ // data for CompleteL
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting>
+ lockStatusData1(lockStatus,lockSetting);
+ dataComplete.Close();
+ lockStatusData.SerialiseL(dataComplete);
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ // send completion
+ iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNone, status.Int());
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST for case RMobilePhone::ELockUniversalPin
+ //-------------------------------------------------------------------------
+ // data for ExpectL
+ lockStatus = RMobilePhone::EStatusLocked;
+ lock = RMobilePhone::ELockUniversalPin;
+ lockSetting = RMobilePhone::ELockSetEnabled;
+ data.Close();
+ phoneLockData.SerialiseL(data);
+
+ // data for CompleteL
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting>
+ lockStatusData2(lockStatus,lockSetting);
+ dataComplete.Close();
+ lockStatusData2.SerialiseL(dataComplete);
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ // send completion
+ iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNone, status.Int());
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST for case RMobilePhone::ELockUniversalPin and with lockSetting == ELockReplaced
+ //-------------------------------------------------------------------------
+ // data for ExpectL
+ lockStatus = RMobilePhone::EStatusLocked;
+ lock = RMobilePhone::ELockUniversalPin;
+ lockSetting = RMobilePhone::ELockReplaced;
+ data.Close();
+ phoneLockData.SerialiseL(data);
+
+ // data for CompleteL
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting>
+ lockStatusData3(lockStatus,lockSetting);
+ dataComplete.Close();
+ lockStatusData3.SerialiseL(dataComplete);
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ // send completion
+ iMockLTSY.CompleteL(EMobilePhoneSetLockSetting, KErrNone, dataComplete);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNone, status.Int());
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST for case RMobilePhone::ELockPhoneToFirstICC
+ //-------------------------------------------------------------------------
+ // data for ExpectL
+ lockStatus = RMobilePhone::EStatusLocked;
+ lock = RMobilePhone::ELockPhoneToFirstICC;
+ lockSetting = RMobilePhone::ELockReplaced;
+ data.Close();
+ phoneLockData.SerialiseL(data);
+
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNotSupported, status.Int());
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST for condition RMobilePhone::ELockSetUnknown != *setting
+ //-------------------------------------------------------------------------
+ // data for ExpectL
+ lockStatus = RMobilePhone::EStatusLocked;
+ lock = RMobilePhone::ELockPhoneToFirstICC;
+ lockSetting = RMobilePhone::ELockSetUnknown;
+ data.Close();
+ phoneLockData.SerialiseL(data);
+
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNotSupported, status.Int());
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST for condition
+ // if (
+ // ( RMobilePhone::ELockSetDisabled == *setting ) &&
+ // ( RMobilePhone::ELockICC == *lock ||
+ // RMobilePhone::ELockUniversalPin == *lock ) &&
+ // !iPin1DisableSupported )
+ //-------------------------------------------------------------------------
+
+ //------- Set iPin1DisableSupported-member to False state -----------------
+ // data for CompleteL
+ TBool supported = EFalse;
+ TMockLtsyData1<TBool> ltsyData(supported);
+ dataComplete.Close();
+ ltsyData.SerialiseL(dataComplete);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ // send completion for calling SetPin1DisableNotSupported
+ iMockLTSY.CompleteL(EMmTsyPhoneGetPin1DisableSupportedIPC, KErrNone, dataComplete);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ //-------------------------------------------------------------------------
+
+ // data for ExpectL
+ lockStatus = RMobilePhone::EStatusLocked;
+ lock = RMobilePhone::ELockICC;
+ lockSetting = RMobilePhone::ELockSetDisabled;
+ data.Close();
+ phoneLockData.SerialiseL(data);
+
+ // call SetLockSetting itself
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrGsm0707OperationNotAllowed, status.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this); // data, this
+ }
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCaps
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetSecurityCaps
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCaps0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ // Get default Caps
+ TUint32 oldCaps;
+ iPhone.GetSecurityCaps(oldCaps);
+ ASSERT_EQUALS(KMultimodeTsyGsmSecurityInitCaps, oldCaps)
+
+ // Change securityCaps
+ RMobilePhone::TMobilePhoneSecurityEvent ev(RMobilePhone::EICCTerminated);
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> evData(ev);
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+
+ // operations taken from CMmPhoneGsmWcdmaExt::UpdateSecurityCaps()
+ TUint32 capsToCompare(0);
+ if ( oldCaps & RMobilePhone::KCapsLockPhone )
+ {
+ capsToCompare |= RMobilePhone::KCapsLockPhone;
+ }
+ if ( oldCaps & RMobilePhone::KCapsAccessPhonePassword )
+ {
+ capsToCompare |= RMobilePhone::KCapsAccessPhonePassword;
+ }
+
+ // Get changed Caps
+ TUint32 newCaps;
+ iPhone.GetSecurityCaps(newCaps);
+
+ ASSERT_EQUALS(capsToCompare, newCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MASC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::AbortSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::AbortSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestAbortSecurityCode0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> secCodeData(secCode);
+ secCodeData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneAbortSecurityCode, data, KErrNotSupported);
+ TInt res = iPhone.AbortSecurityCode(secCode);
+
+ ASSERT_EQUALS(KErrNotSupported, res)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneAbortSecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneAbortSecurityCode, KErrGeneral);
+
+ res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrGeneral, res)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::AbortSecurityCode when result is not cached.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneAbortSecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneAbortSecurityCode, KErrNone);
+
+ res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrNone, res)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::AbortSecurityCode
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneAbortSecurityCode, KErrNone);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MASC-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::AbortSecurityCode with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::AbortSecurityCode and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestAbortSecurityCode0005L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> secCodeData(secCode);
+ secCodeData.SerialiseL(data);
+ //-------------------------------------------------------------------------
+ // Test A: Test timeout of RMobilePhone::AbortSecurityCode
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneAbortSecurityCode, data);
+
+ TInt res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrTimedOut, res)
+
+ // Done !
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MASC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::AbortSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::AbortSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestAbortSecurityCode0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockPhoneDevice;//ELockUSimApp;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;
+
+ //-------------------------------------------------------------------------
+ // Verify that SetLockSetting will be completed
+ //------------------------------------------------------------------------
+ iPhone.SetLockSetting(status, lock, lockSetting);
+
+ TInt res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrNone, res)
+
+ //SetLockSetting should be completed with KErrAbort.
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAbort, status.Int())
+ AssertMockLtsyStatusL();
+ // Done !
+ CleanupStack::PopAndDestroy(1, this); //this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MASC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::AbortSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::AbortSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestAbortSecurityCode0007L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneFdnSetting fdnSetting = RMobilePhone::EFdnSetOn;
+
+ //-------------------------------------------------------------------------
+ // Verify that SetFdnSetting will be completed
+ //-------------------------------------------------------------------------
+ iPhone.SetFdnSetting(status, fdnSetting);
+
+ TInt res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrNone, res)
+
+ //SetFdnSetting should be completed with KErrAbort.
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAbort, status.Int())
+ AssertMockLtsyStatusL();
+ // Done !
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MCSC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::ChangeSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::ChangeSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestChangeSecurityCode0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ TRequestStatus reqStatus;
+
+ _LIT(KOldPwd,"old");
+ _LIT(KNewPwd,"new");
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange;
+ pwdChange.iNewPassword.Copy(KNewPwd);
+ pwdChange.iOldPassword.Copy(KOldPwd);
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhonePasswordChangeV1> pwdData(secCode,pwdChange);
+ pwdData.SerialiseL(data);
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneChangeSecurityCode,data,KErrNotSupported);
+
+ iPhone.ChangeSecurityCode(reqStatus,secCode, pwdChange);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneChangeSecurityCode,data);
+ iMockLTSY.CompleteL(EMobilePhoneChangeSecurityCode, KErrGeneral, dataComplete);
+
+ iPhone.ChangeSecurityCode(reqStatus,secCode, pwdChange);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::ChangeSecurityCode when result is not cached.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneChangeSecurityCode,data);
+ iMockLTSY.CompleteL(EMobilePhoneChangeSecurityCode, KErrNone, dataComplete);
+
+ iPhone.ChangeSecurityCode(reqStatus,secCode, pwdChange);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::ChangeSecurityCode
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(reqStatus);
+ iMockLTSY.CompleteL(EMobilePhoneChangeSecurityCode, KErrNone, dataComplete);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data, dataComplete, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MCSC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::ChangeSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobilePhone::ChangeSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestChangeSecurityCode0002L()
+ {
+
+// This test should test cancellation of ChangeSecurityCode
+// 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);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ TRequestStatus reqStatus;
+
+ _LIT(KOldPwd,"old");
+ _LIT(KNewPwd,"new");
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange;
+ pwdChange.iNewPassword.Copy(KNewPwd);
+ pwdChange.iOldPassword.Copy(KOldPwd);
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhonePasswordChangeV1> pwdData(secCode,pwdChange);
+ pwdData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobilePhone::ChangeSecurityCode
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneChangeSecurityCode, data);
+ iPhone.ChangeSecurityCode(reqStatus, secCode, pwdChange);
+ // send canceling...
+ iPhone.CancelAsyncRequest(EMobilePhoneChangeSecurityCode);
+
+ //send completion
+ iMockLTSY.CompleteL(EMobilePhoneChangeSecurityCode, KErrNone, dataComplete);
+ // wait for completion
+ User::WaitForRequest(mockLtsyStatus);
+
+ // wait for NotifyStatusChange
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int()); //Common TSY doesn't cancel this function.
+
+ AssertMockLtsyStatusL();
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ // User::WaitForRequest(mockLtsyStatus);
+ CleanupStack::PopAndDestroy(3); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MCSC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::ChangeSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobilePhone::ChangeSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestChangeSecurityCode0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ // 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);
+
+ TRequestStatus reqStatus;
+
+ _LIT(KOldPwd,"old");
+ _LIT(KNewPwd,"new");
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange;
+ pwdChange.iNewPassword.Copy(KNewPwd);
+ pwdChange.iOldPassword.Copy(KOldPwd);
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhonePasswordChangeV1> pwdData(secCode,pwdChange);
+ pwdData.SerialiseL(data);
+
+ TRequestStatus reqStatus2;
+
+ _LIT(KOldPwd2,"old2");
+ _LIT(KNewPwd2,"new2");
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode2 = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange2;
+ pwdChange2.iNewPassword.Copy(KNewPwd2);
+ pwdChange2.iOldPassword.Copy(KOldPwd2);
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhonePasswordChangeV1> pwdData2(secCode2,pwdChange2);
+ pwdData2.SerialiseL(data2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::ChangeSecurityCode
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneChangeSecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneChangeSecurityCode, KErrNone, dataComplete);
+
+ iMockLTSY.ExpectL(EMobilePhoneChangeSecurityCode, data2);
+ iMockLTSY.CompleteL(EMobilePhoneChangeSecurityCode, KErrNone, dataComplete);
+
+ iPhone.ChangeSecurityCode(reqStatus, secCode, pwdChange);
+ phone2.ChangeSecurityCode(reqStatus2, secCode2, pwdChange2);
+
+
+ // wait for first phone SetLockSetting
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+
+ // wait for second phone SetLockSetting.
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(6, this); // phone2, telServer2, data, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MCSC-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::ChangeSecurityCode with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::ChangeSecurityCode and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestChangeSecurityCode0005L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus reqStatus;
+
+ _LIT(KOldPwd,"old");
+ _LIT(KNewPwd,"new");
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange;
+ pwdChange.iNewPassword.Copy(KNewPwd);
+ pwdChange.iOldPassword.Copy(KOldPwd);
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhonePasswordChangeV1> pwdData(secCode,pwdChange);
+ pwdData.SerialiseL(data);
+ //-------------------------------------------------------------------------
+ // Test A: Test timeout of RMobilePhone::ChangeSecurityCode
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobilePhoneChangeSecurityCode, data);
+ iPhone.ChangeSecurityCode(reqStatus, secCode, pwdChange);
+
+ User::WaitForRequest(reqStatus);
+
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data, KErrNotSupported);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrGeneral, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::VerifySecurityCode when result is not cached.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::VerifySecurityCode
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(reqStatus);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::VerifySecurityCode
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ AssertMockLtsyStatusL();
+
+ _LIT(KGoodPin,"12345");
+ _LIT(KBadPin1,"12");
+ _LIT(KBadPin2,"1a345");
+ _LIT(KGoodPuk,"12345678");
+ _LIT(KBadPuk1,"1");
+ _LIT(KBadPuk2,"12345z78");
+
+ // short PIN
+ secCode = RMobilePhone::ESecurityCodePin1;
+ iPhone.VerifySecurityCode(reqStatus, secCode, KBadPin1(), KGoodPuk());
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ // PIN with non-numeric characters
+ secCode = RMobilePhone::ESecurityCodePin2;
+ iPhone.VerifySecurityCode(reqStatus, secCode, KBadPin2(), KGoodPuk());
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ // short PUK
+ secCode = RMobilePhone::ESecurityCodePuk1;
+ iPhone.VerifySecurityCode(reqStatus, secCode, KGoodPin(), KBadPuk1());
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ // PUK with non-numeric characters
+ secCode = RMobilePhone::ESecurityCodePuk2;
+ iPhone.VerifySecurityCode(reqStatus, secCode, KGoodPin(), KBadPuk2());
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0002L()
+ {
+
+// This test should test cancellation of VerifySecurityCode
+// 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);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobilePhone::VerifySecurityCode
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ iPhone.CancelAsyncRequest(EMobilePhoneVerifySecurityCode);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+
+ User::WaitForRequest(mockLtsyStatus);
+ User::WaitForRequest(reqStatus);
+
+ ASSERT_EQUALS(KErrNone, reqStatus.Int()) //Common TSY doesn't cancel this function.
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3); // data, this
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ // 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);
+
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ _LIT(KPwd2,"pwd2");
+ _LIT(KUnblockPwd2, "unblock2");
+
+ TRequestStatus reqStatus2;
+ RMobilePhone::TMobilePhoneSecurityCode secCode2 = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePassword pwd2;
+ RMobilePhone::TMobilePassword unblockPwd2;
+
+ pwd2.Copy(KPwd2);
+ unblockPwd2.Copy(KUnblockPwd2);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes2;
+ twoCodes2.iCode.Copy(KPwd2);
+ twoCodes2.iUnblockCode.Copy(KUnblockPwd2);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData2(secCode2,twoCodes2);
+ verifyData2.SerialiseL(data2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::VerifySecurityCode
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ phone2.VerifySecurityCode(reqStatus2, secCode2, pwd2, unblockPwd2);
+
+
+ // wait for first phone SetLockSetting
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ // wait for second phone SetLockSetting.
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(6, this); // phone2, telServer2, data, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0005L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test timeout of RMobilePhone::VerifySecurityCode
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ _LIT(KEmpty,"");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KEmpty);
+ unblockPwd.Copy(KEmpty);
+
+ //-------------------------------------------------------------------------
+ // RMobilePhone::VerifySecurityCode when code length is 0.
+ //-------------------------------------------------------------------------
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(1, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePuk1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode when security code is ESecurityCodePuk1 or ESecurityCodePuk2.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePuk1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ RBuf8 dataSls;
+ CleanupClosePushL(dataSls);
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;
+ TLockSettingPassword lockSettingPassword;
+ lockSettingPassword.iPassword.Copy(KNullDesC);
+ RMobilePhone::TMobilePhoneLock& lock( lockSettingPassword.iLock );
+ RMobilePhone::TMobilePhoneLockSetting& lockSetting( lockSettingPassword.iSetting );
+ lock = RMobilePhone::ELockHiddenKey;
+ lockSetting = RMobilePhone::ELockSetEnabled;
+ TMockLtsyData1<TLockSettingPassword> phoneLockData(lockSettingPassword);
+ phoneLockData.SerialiseL(dataSls);
+
+ RBuf8 dataSls_;
+ CleanupClosePushL(dataSls_);
+
+ RBuf8 dataCompleteSls;
+ CleanupClosePushL(dataCompleteSls);
+
+ TLockSettingPassword lockSettingPassword_;
+ lockSettingPassword_.iPassword.Copy(KPwd);
+ RMobilePhone::TMobilePhoneLock& lock_( lockSettingPassword_.iLock );
+ RMobilePhone::TMobilePhoneLockSetting& lockSetting_( lockSettingPassword_.iSetting );
+ lock_ = RMobilePhone::ELockPhoneDevice;
+ lockSetting_ = RMobilePhone::ELockSetUnknown;
+ TMockLtsyData1<TLockSettingPassword> phoneLockData_(lockSettingPassword_);
+ phoneLockData_.SerialiseL(dataSls_);
+
+ TRequestStatus mockLtsyStatus;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> lockStatusData(lockStatus,lockSetting);
+ lockStatusData.SerialiseL(dataCompleteSls);
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode when SetLockSetting is called.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneSetLockSetting, dataSls);
+ iPhone.SetLockSetting(status, lock, lockSetting);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.ExpectL(EMobilePhoneSetLockSetting, dataSls_);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+ User::WaitForRequest(mockLtsyStatus);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNone, status.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePuk1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockUniversalPin;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockReplaced;
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode when security code is ESecurityCodePuk1 or ESecurityCodePuk2.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data, KErrGeneral);
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrGeneral, status.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0010
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0010L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePuk1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneFdnSetting fdnSetting = RMobilePhone::EFdnSetOn;
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode when security code is ESecurityCodePuk1 or ESecurityCodePuk2.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data, KErrGeneral);
+ iPhone.SetFdnSetting(status, fdnSetting);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrGeneral, status.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePuk1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockUniversalPin;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockReplaced;
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode when security code is ESecurityCodePuk1 or ESecurityCodePuk2.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrGeneral, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAccessDenied, status.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this); // data, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ // Initialize data for VerifySecurityEvent
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePuk1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ //Initialize data for SetLockSetting
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockUniversalPin;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockReplaced;
+
+
+ //-------------------------------------------------------------------------
+ // RMobilePhone::VerifySecurityCode
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAccessDenied, status.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0013L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ // Initialize data for VerifySecurityEvent
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePuk1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ //Initialize data for SetFdnSetting
+ RBuf8 dataFdn;
+ CleanupClosePushL(dataFdn);
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneFdnSetting fdnSetting = RMobilePhone::EFdnSetOff;
+ TMockLtsyData1<RMobilePhone::TMobilePhoneFdnSetting> fdnData(fdnSetting);
+ fdnData.SerialiseL(dataFdn);
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode complete with KErrGeneral
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrGeneral, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ iPhone.SetFdnSetting(status, fdnSetting);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrGeneral, status.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // Now complete it with KErrNone
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+ iPhone.SetFdnSetting(status, fdnSetting);
+
+ //CompleteVerifySecurityL will transfer SetFdnSetting call to MockL.
+ iMockLTSY.ExpectL(EMobilePhoneSetFdnSetting, dataFdn);
+ iMockLTSY.CompleteL(EMobilePhoneSetFdnSetting, KErrNone);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNone, status.Int())
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MVSC-0014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestVerifySecurityCode0014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblock");
+
+ // Initialize data for VerifySecurityEvent
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(data);
+
+ //Initialize data for SetLockSetting
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMmTsyBootNotifySecurityReadyIPC, KErrNone);
+ User::WaitForRequest(mockLtsyStatus);
+
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, data);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrGeneral, dataComplete);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data, this
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ TRequestStatus mockLtsyStatus;
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEventRes;
+ RMobilePhone::TMobilePhoneSecurityEvent secEvent = RMobilePhone::EPhonePasswordRequired;
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> eventData(secEvent);
+ eventData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMmTsySimGetICCType, dataExpect);
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrGeneral, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::NotifySecurityEvent when result is not cached.
+ //-------------------------------------------------------------------------
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(secEvent, secEventRes)
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::NotifySecurityEvent
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST D: RMobilePhone::NotifySecurityEvent again, this time CTSY
+ // will get result from the cache.
+ //-------------------------------------------------------------------------
+ secEventRes = RMobilePhone::EPhonePasswordVerified; //change the value to make shure that NotifySecurityEvent will write the correct value to secEventRes.
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(secEvent, secEventRes)
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0002L()
+ {
+
+// This test should test cancellation of NotifySecurityEvent
+// 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);
+
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEventRes;
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobilePhone::NotifySecurityEvent
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMmTsySimGetICCType, data);
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+ iPhone.CancelAsyncRequest(EMobilePhoneNotifySecurityEvent);
+ User::WaitForRequest(mockLtsyStatus);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ // 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);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEventRes;
+ RMobilePhone::TMobilePhoneSecurityEvent secEvent = RMobilePhone::EPhonePasswordVerified;
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> eventData(secEvent);
+ eventData.SerialiseL(data);
+
+ TRequestStatus reqStatus2;
+ RMobilePhone::TMobilePhoneSecurityEvent secEventRes2;
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::NotifySecurityEvent
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMmTsySimGetICCType, dataExpect);
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+ phone2.NotifySecurityEvent(reqStatus2, secEventRes2);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ User::WaitForRequest(reqStatus);
+ User::WaitForRequest(reqStatus2);
+
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(secEvent, secEventRes)
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+ ASSERT_EQUALS(secEvent, secEventRes2)
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, dataExpect, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ RBuf8 dataVerify;
+ CleanupClosePushL(dataVerify);
+
+ RBuf8 dataCompleteVerify;
+ CleanupClosePushL(dataCompleteVerify);
+
+ TRequestStatus mockLtsyStatus;
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEventRes;
+ RMobilePhone::TMobilePhoneSecurityEvent secEvent = RMobilePhone::EPin1Verified;
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> eventData(secEvent);
+ eventData.SerialiseL(data);
+
+
+ _LIT(KPwd,"1234");
+ _LIT(KUnblockPwd, "12345678");
+
+ TRequestStatus reqStatusVerify;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePassword pwd;
+ RMobilePhone::TMobilePassword unblockPwd;
+
+ pwd.Copy(KPwd);
+ unblockPwd.Copy(KUnblockPwd);
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode,twoCodes);
+ verifyData.SerialiseL(dataVerify);
+
+ //--------------------------------------------------------------------------------
+ //for coverage increase
+ //--------------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMmTsySimGetICCType, dataExpect);
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+
+ iMockLTSY.ExpectL(EMobilePhoneVerifySecurityCode, dataVerify);
+ iMockLTSY.CompleteL(EMobilePhoneVerifySecurityCode, KErrNone, dataCompleteVerify);
+ iPhone.VerifySecurityCode(reqStatusVerify, secCode, pwd, unblockPwd);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(secEvent, secEventRes)
+
+ User::WaitForRequest(reqStatusVerify);
+ ASSERT_EQUALS(KErrNone, reqStatusVerify.Int())
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus mockLtsyStatus;
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEvent = RMobilePhone::EPin2Required;
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> eventData(secEvent);
+ eventData.SerialiseL(data);
+
+ //--------------------------------------------------------------------------------
+ // Unsolicited completion of RMobilePhone::NotifySecurityEvent
+ // from LTSY. when event is EPin2Required.
+ //--------------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+ // Done !
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus mockLtsyStatus;
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEvent = RMobilePhone::EPhonePasswordRequired;
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> eventData(secEvent);
+ eventData.SerialiseL(data);
+
+ //--------------------------------------------------------------------------------
+ //for coverage increase
+ //--------------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+
+ AssertMockLtsyStatusL();
+ // Done !
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus mockLtsyStatus;
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEvent = RMobilePhone::EPhonePasswordRequired;
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> eventData(secEvent);
+ eventData.SerialiseL(data);
+
+ RBuf8 dataSls;
+ CleanupClosePushL(dataSls);
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;
+ TLockSettingPassword lockSettingPassword;
+ lockSettingPassword.iPassword.Copy(KNullDesC);
+ RMobilePhone::TMobilePhoneLock& lock( lockSettingPassword.iLock );
+ RMobilePhone::TMobilePhoneLockSetting& lockSetting( lockSettingPassword.iSetting );
+ lock = RMobilePhone::ELockPhoneDevice;//ELockUSimApp;
+ lockSetting = RMobilePhone::ELockSetEnabled;
+ TMockLtsyData1<TLockSettingPassword> phoneLockData(lockSettingPassword);
+ phoneLockData.SerialiseL(dataSls);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> lockStatusData(lockStatus,lockSetting);
+
+ //--------------------------------------------------------------------------------
+ //for coverage increase
+ //--------------------------------------------------------------------------------
+ iPhone.SetLockSetting(status, lock, lockSetting);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+ // Request status passed to set lock setting should be completed with KErrACcessDenied.
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAccessDenied, status.Int())
+
+ AssertMockLtsyStatusL();
+ // Done !
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSE-0010
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityEvent
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityEvent
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityEvent0010L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus mockLtsyStatus;
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityEvent secEvent = RMobilePhone::EPhonePasswordRequired;
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> eventData(secEvent);
+ eventData.SerialiseL(data);
+
+ //--------------------------------------------------------------------------------
+ //for coverage increase
+ //--------------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNLIC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyLockInfoChange
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifyLockInfoChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifyLockInfoChange0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data3G;
+ CleanupClosePushL(data3G);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockPhoneDevice;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfoV1;
+ lockInfoV1.iSetting = RMobilePhone::ELockSetEnabled;
+ lockInfoV1.iStatus = RMobilePhone::EStatusLocked;
+
+ RMobilePhone::TMobilePhoneLockInfoV1Pckg pckgData(lockInfoV1);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockInfoV1, RMobilePhone::TMobilePhoneLock> lockInfoData(lockInfoV1, lock);
+ lockInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::NotifyLockInfoChange when result is not cached.
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ //Repeat the previos tesat for coverage increase
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: for coverage increasing with RMobilePhone::ELockPhoneToICC
+ // as parameter
+ //-------------------------------------------------------------------------
+ lock = RMobilePhone::ELockPhoneToICC;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockInfoV1, RMobilePhone::TMobilePhoneLock>
+ lockInfoData2(lockInfoV1, lock);
+ data.Close();
+ lockInfoData2.SerialiseL(data);
+
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: repeat the test with RMobilePhone::ELockPhoneToICC
+ // as parameter for coverage increase
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: for coverage increasing with RMobilePhone::ELockUniversalPin
+ // as parameter
+ //-------------------------------------------------------------------------
+
+ lock = RMobilePhone::ELockUniversalPin;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockInfoV1, RMobilePhone::TMobilePhoneLock>
+ lockInfoData3(lockInfoV1, lock);
+ data.Close();
+ lockInfoData3.SerialiseL(data);
+
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST C: for coverage increasing with RMobilePhone::ELockUniversalPin
+ // as parameter and iCurrentICCType == EICCTypeSim3G
+ //-------------------------------------------------------------------------
+
+ //----------- making ICC3G ----------------------------
+ TRequestStatus mockLtsyStatus;
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ TICCType type(EICCTypeSim3G);
+
+ TMockLtsyData1<TICCType> iccData(type);
+ iccData.SerialiseL(data3G);
+
+ iMockLTSY.CompleteL(EMmTsySimGetICCType, KErrNone, data3G);
+
+ iMockLTSY.ExpectL(EMmTsySecurityGetSimActivePinStateIPC);
+ iMockLTSY.CompleteL(EMmTsySecurityGetSimActivePinStateIPC, KErrNone);
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ //------------------------------------------------------
+
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: repeat the test with RMobilePhone::ELockUniversalPin
+ // as parameter for coverage increase
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: for coverage increasing with RMobilePhone::ELockICC
+ // as parameter
+ //-------------------------------------------------------------------------
+ lock = RMobilePhone::ELockICC;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockInfoV1, RMobilePhone::TMobilePhoneLock>
+ lockInfoData4(lockInfoV1, lock);
+ data.Close();
+ lockInfoData4.SerialiseL(data);
+
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: repeat the test with RMobilePhone::ELockICC
+ // as parameter for coverage increase
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: for coverage increasing with RMobilePhone::ELockPhoneToFirstICC
+ // as parameter
+ //-------------------------------------------------------------------------
+ lock = RMobilePhone::ELockPhoneToFirstICC;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockInfoV1, RMobilePhone::TMobilePhoneLock>
+ lockInfoData5(lockInfoV1, lock);
+ data.Close();
+ lockInfoData5.SerialiseL(data);
+
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrGeneral, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::NotifyLockInfoChange
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(reqStatus);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data3G, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNLIC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::NotifyLockInfoChange
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobilePhone::NotifyLockInfoChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifyLockInfoChange0002L()
+ {
+
+// This test should test cancellation of NotifyLockInfoChange
+// 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);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockPhoneDevice;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfoV1;
+ lockInfoV1.iSetting = RMobilePhone::ELockSetEnabled;
+ lockInfoV1.iStatus = RMobilePhone::EStatusLocked;
+
+ RMobilePhone::TMobilePhoneLockInfoV1Pckg pckgData(lockInfoV1);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockInfoV1, RMobilePhone::TMobilePhoneLock> lockInfoData(lockInfoV1, lock);
+ lockInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobilePhone::NotifyLockInfoChange
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iPhone.CancelAsyncRequest(EMobilePhoneNotifyLockInfoChange);
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2); // data, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNLIC-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyLockInfoChange with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifyLockInfoChange with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifyLockInfoChange0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RMobilePhone::NotifyLockInfoChange
+ //-------------------------------------------------------------------------
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockPhoneDevice;
+ TBuf8<1> lockInfo;
+
+ iPhone.NotifyLockInfoChange(reqStatus, lock, lockInfo);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(this); // this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNLIC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::NotifyLockInfoChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobilePhone::NotifyLockInfoChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifyLockInfoChange0004L()
+ {
+ 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(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+
+ //Data for iMockLTSY->CompleteL
+ RMobilePhone::TMobilePhoneLock lockComplete = RMobilePhone::ELockPhoneDevice;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfoV1;
+ lockInfoV1.iSetting = RMobilePhone::ELockSetEnabled;
+ lockInfoV1.iStatus = RMobilePhone::EStatusLocked;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockInfoV1, RMobilePhone::TMobilePhoneLock> lockInfoData(lockInfoV1, lockComplete);
+ lockInfoData.SerialiseL(data);
+
+ //Variables that will contain result data after request status will be completed.
+ RMobilePhone::TMobilePhoneLock lock1;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+ RMobilePhone::TMobilePhoneLockInfoV1Pckg pckgData(lockInfo);
+
+ //Variables that will contain result data after second request status will be completed.
+ RMobilePhone::TMobilePhoneLock lock2;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfo2;
+ RMobilePhone::TMobilePhoneLockInfoV1Pckg pckgData2(lockInfo2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::NotifyLockInfoChange
+ //-------------------------------------------------------------------------
+
+ iPhone.NotifyLockInfoChange(reqStatus, lock1, pckgData);
+ phone2.NotifyLockInfoChange(reqStatus2, lock2, pckgData2);
+
+ iMockLTSY.CompleteL(EMobilePhoneNotifyLockInfoChange, KErrNone, data);
+
+ User::WaitForRequest(reqStatus);
+ User::WaitForRequest(reqStatus2);
+
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData2().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData2().iStatus)
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSCI-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCodeInfo
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetSecurityCodeInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCodeInfo0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData(secCode);
+ codeData.SerialiseL(dataExpect);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, dataExpect, KErrNotSupported);
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, dataExpect);
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrGeneral, data);
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::GetSecurityCodeInfo when result is not cached.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, dataExpect);
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, data);
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData().iRemainingEntryAttempts)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::GetSecurityCodeInfo
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSCI-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::GetSecurityCodeInfo
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobilePhone::GetSecurityCodeInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCodeInfo0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData(secCode);
+ codeData.SerialiseL(dataExpect);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobilePhone::GetSecurityCodeInfo
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, dataExpect);
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+ iPhone.CancelAsyncRequest(EMobilePhoneGetSecurityCodeInfo);
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ // Wait for completion of GetSecurityCodeInfo
+ User::WaitForRequest(reqStatus);
+ // Check status is KErrCancel
+ ASSERT_EQUALS(KErrCancel,reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSCI-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCodeInfo with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetSecurityCodeInfo with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCodeInfo0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ TBuf8<1> smallBuf;
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RMobilePhone::GetSecurityCodeInfo
+ //-------------------------------------------------------------------------
+ // CTSY should return an error straight away
+
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, smallBuf);
+ User::WaitForRequest(reqStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ // Done !
+ CleanupStack::PopAndDestroy(this); // this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSCI-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::GetSecurityCodeInfo
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobilePhone::GetSecurityCodeInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCodeInfo0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ RBuf8 dataComplete2;
+ CleanupClosePushL(dataComplete2);
+
+ // 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);
+
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData(secCode);
+ codeData.SerialiseL(data);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(dataComplete);
+
+ TRequestStatus reqStatus2;
+ RMobilePhone::TMobilePhoneSecurityCode secCode2 = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV52;
+ codeInfoV52.iRemainingEntryAttempts = 3;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV52;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData2(codeV52);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData2(secCode2);
+ codeData2.SerialiseL(data2);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData2(secCode2, codeInfoV52);
+ codeInfoData2.SerialiseL(dataComplete2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::GetSecurityCodeInfo
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, data);
+
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, dataComplete);
+
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, data2);
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, dataComplete2);
+
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+ phone2.GetSecurityCodeInfo(reqStatus2, secCode2, pckgData2);
+
+
+ // wait for first phone GetSecurityCodeInfo
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData().iRemainingEntryAttempts)
+
+
+ // wait for second phone GetsecurityCodeInfo.
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+ ASSERT_EQUALS(codeInfoV52.iRemainingEntryAttempts, pckgData2().iRemainingEntryAttempts)
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSCI-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCodeInfo with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetSecurityCodeInfo and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCodeInfo0005L()
+ {
+
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ // 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);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData(secCode);
+ codeData.SerialiseL(data);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(dataComplete);
+ //-------------------------------------------------------------------------
+ // Test A: Send multiple client requests RMobilePhone::ChangeSecurityCode
+ // One request successfully returns, other one timed out.
+ // Multiple request is sent just to test that the proper one is timed out.
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, data);
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, dataComplete);
+
+ TRequestStatus reqStatus2;
+ RMobilePhone::TMobilePhoneSecurityCode secCode2 = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV52;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData2(codeV52);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData2(secCode2);
+ codeData2.SerialiseL(data2);
+
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, data2);
+
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+
+ phone2.GetSecurityCodeInfo(reqStatus2, secCode2, pckgData2);
+
+ // wait for first phone GetSecurityCodeInfo
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData().iRemainingEntryAttempts)
+
+ // wait for second phone GetsecurityCodeInfo which will be timed out.
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus2.Int())
+
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(6, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSCI-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCodeInfo
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetSecurityCodeInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCodeInfo0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ RBuf8 dataComplete2;
+ CleanupClosePushL(dataComplete2);
+
+ // 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);
+
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData(secCode);
+ codeData.SerialiseL(data);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(dataComplete);
+
+ TRequestStatus reqStatus2;
+ RMobilePhone::TMobilePhoneSecurityCode secCode2 = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV52;
+ codeInfoV52.iRemainingEntryAttempts = 3;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV52;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData2(codeV52);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData2(secCode2);
+ codeData2.SerialiseL(data2);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData2(secCode2, codeInfoV52);
+ codeInfoData2.SerialiseL(dataComplete2);
+
+ //----------------------------------------------------------------------------
+ // Covering condition when there is already one request for security code and
+ // a second one is done.
+ //----------------------------------------------------------------------------
+ ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 71003);
+ ASSERT_TRUE(EFalse)
+
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, data);
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, dataComplete);
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, dataComplete2);
+ phone2.GetSecurityCodeInfo(reqStatus2, secCode, pckgData2);
+
+
+ // wait for first phone GetSecurityCodeInfo
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData().iRemainingEntryAttempts)
+
+
+ // wait for second phone GetsecurityCodeInfo.
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+ ASSERT_EQUALS(codeInfoV52.iRemainingEntryAttempts, pckgData2().iRemainingEntryAttempts)
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MGSCI-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCodeInfo
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetSecurityCodeInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestGetSecurityCodeInfo0007L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ RBuf8 dataComplete2;
+ CleanupClosePushL(dataComplete2);
+
+ // 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);
+
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData(secCode);
+ codeData.SerialiseL(data);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(dataComplete);
+
+ TRequestStatus reqStatus2;
+ RMobilePhone::TMobilePhoneSecurityCode secCode2 = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV52;
+ codeInfoV52.iRemainingEntryAttempts = 3;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV52;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData2(codeV52);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData2(secCode2);
+ codeData2.SerialiseL(data2);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData2(secCode2, codeInfoV52);
+ codeInfoData2.SerialiseL(dataComplete2);
+
+ //-----------------------------------------------------------------------------
+ // Cover condition if there are more than one GetSecurityCodeInfo request when cancelling some request.
+ //-----------------------------------------------------------------------------
+ // This defect was fixed. For more information see defect description
+ //ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 71004);
+
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, data);
+ iMockLTSY.CompleteL(EMobilePhoneGetSecurityCodeInfo, KErrNone, dataComplete);
+
+ iMockLTSY.ExpectL(EMobilePhoneGetSecurityCodeInfo, data2);
+
+
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+ phone2.GetSecurityCodeInfo(reqStatus2, secCode2, pckgData2);
+ phone2.CancelAsyncRequest(EMobilePhoneGetSecurityCodeInfo);
+
+ User::WaitForRequest(mockLtsyStatus);
+
+ // wait for second phone GetsecurityCodeInfo.
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrCancel, reqStatus2.Int());
+
+
+ // wait for first phone GetSecurityCodeInfo
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData().iRemainingEntryAttempts)
+
+ AssertMockLtsyStatusL();
+
+
+
+ // Done !
+ CleanupStack::PopAndDestroy(7, this); // phone2, telServer2, data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSCIC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityCodeInfoChange
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityCodeInfoChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityCodeInfoChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iPhone.NotifySecurityCodeInfoChange(reqStatus, secCode, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityCodeInfoChange, KErrGeneral, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::GetSecurityCodeInfo when result is not cached.
+ //-------------------------------------------------------------------------
+ iPhone.NotifySecurityCodeInfoChange(reqStatus, secCode, pckgData);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityCodeInfoChange, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData().iRemainingEntryAttempts)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::GetSecurityCodeInfo
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityCodeInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSCIC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::GetSecurityCodeInfo
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobilePhone::GetSecurityCodeInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityCodeInfoChange0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCode, codeInfoV5);
+ codeInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobilePhone::GetLockInfo
+ //-------------------------------------------------------------------------
+ iPhone.NotifySecurityCodeInfoChange(reqStatus, secCode, pckgData);
+ iPhone.CancelAsyncRequest(EMobilePhoneNotifySecurityCodeInfoChange);
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityCodeInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ // Wait for completion of GetSecurityCodeInfo
+ User::WaitForRequest(reqStatus);
+ // Check status is KErrCancel
+ ASSERT_EQUALS(KErrCancel,reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSCIC-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCodeInfo with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityCodeInfoChange with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityCodeInfoChange0003L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ TBuf8<1> smallBuf;
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RMobilePhone::GetLockInfo
+ //-------------------------------------------------------------------------
+
+ // CTSY should return an error straight away
+
+ iPhone.NotifySecurityCodeInfoChange(reqStatus, secCode, smallBuf);
+ User::WaitForRequest(reqStatus);
+
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy( this ); // this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-PSEC-MNSCIC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::NotifySecurityCodeInfoChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobilePhone::NotifySecurityCodeInfoChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityCodeInfoChange0004L()
+ {
+
+ 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(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+
+ RMobilePhone::TMobilePhoneSecurityCode secCodeComplete = RMobilePhone::ESecurityCodePhonePassword;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfoV5;
+ codeInfoV5.iRemainingEntryAttempts = 4;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TMobilePhoneSecurityCodeInfoV5> codeInfoData(secCodeComplete, codeInfoV5);
+ codeInfoData.SerialiseL(data);
+
+ // For first request
+ RMobilePhone::TMobilePhoneSecurityCode secCode1 = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV51;
+ codeV51.iRemainingEntryAttempts = 0;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData1(codeV51);
+
+ // For second request
+ RMobilePhone::TMobilePhoneSecurityCode secCode2 = RMobilePhone::ESecurityCodePin1;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV52;
+ codeV52.iRemainingEntryAttempts = 0;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData2(codeV52);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::NotifySecurityCodeInfoChange
+ //-------------------------------------------------------------------------
+
+ iPhone.NotifySecurityCodeInfoChange(reqStatus, secCode1, pckgData1);
+ phone2.NotifySecurityCodeInfoChange(reqStatus2, secCode2, pckgData2);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityCodeInfoChange, KErrNone, data);
+
+ // Wait for the first complete.
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData1().iRemainingEntryAttempts);
+ ASSERT_EQUALS(secCodeComplete, secCode1);
+
+ // Wait for the second complete.
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+ ASSERT_EQUALS(codeInfoV5.iRemainingEntryAttempts, pckgData2().iRemainingEntryAttempts);
+ ASSERT_EQUALS(secCodeComplete, secCode2);
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-NTWS-MNSCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityCapsChange
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityCapsChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityCapsChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+
+ // Check basic expected operation
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ TUint32 oldCaps;
+ iPhone.GetSecurityCaps(oldCaps);
+
+ TRequestStatus requestStatus;
+ TUint32 newCaps;
+
+ //----------------------------
+ iPhone.NotifySecurityCapsChange(requestStatus, newCaps);
+
+ RMobilePhone::TMobilePhoneSecurityEvent ev(RMobilePhone::ENoICCFound);
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> evData(ev);
+
+ ev = RMobilePhone::ENoICCFound;
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+
+ User::WaitForRequest(requestStatus);
+
+ TUint32 capsToCompare(0);
+
+ if ( oldCaps & RMobilePhone::KCapsLockPhone )
+ {
+ capsToCompare |= RMobilePhone::KCapsLockPhone;
+ }
+ if ( oldCaps & RMobilePhone::KCapsAccessPhonePassword )
+ {
+ capsToCompare |= RMobilePhone::KCapsAccessPhonePassword;
+ }
+
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(capsToCompare, newCaps);
+ //----------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ ev = RMobilePhone::EICCTerminated;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+
+ iPhone.NotifySecurityCapsChange(requestStatus, newCaps);
+
+ ev = RMobilePhone::EPin1Required;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPuk1Required;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPin2Required;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPuk2Required;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPhonePasswordRequired;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPin1Verified;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPin2Verified;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPuk1Verified;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPuk2Verified;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+
+ User::WaitForRequest(requestStatus);
+
+ capsToCompare = 0;
+
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(capsToCompare, newCaps);
+
+ //- making ICC3G ----------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ TICCType type(EICCTypeSim3G);
+
+ TMockLtsyData1<TICCType> iccData(type);
+ data.Close();
+ iccData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMmTsySimGetICCType, KErrNone, data);
+
+ iMockLTSY.ExpectL(EMmTsySecurityGetSimActivePinStateIPC);
+ iMockLTSY.CompleteL(EMmTsySecurityGetSimActivePinStateIPC, KErrNone);
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+
+ //--------------------------------------------
+
+ iPhone.GetSecurityCaps(oldCaps);
+
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iPhone.NotifySecurityCapsChange(requestStatus, newCaps);
+
+ ev = RMobilePhone::EUniversalPinRequired;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EUniversalPukRequired;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPhonePasswordRequired;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EUniversalPinVerified;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EUniversalPukVerified;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ ev = RMobilePhone::EPhonePasswordVerified;
+ data.Close();
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+
+ User::WaitForRequest(requestStatus);
+
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(oldCaps, newCaps);
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+}
+
+/**
+@SYMTestCaseID BA-CTSY-NTWS-MNSCC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::NotifySecurityCapsChange
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobilePhone::NotifySecurityCapsChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityCapsChange0002L()
+ {
+
+// This test should test cancellation of NotifySecurityCapsChange
+// 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::NotifySecurityCapsChange
+ //-------------------------------------------------------------------------
+ TRequestStatus requestStatus;
+ TUint32 caps;
+
+ iPhone.NotifySecurityCapsChange(requestStatus, caps);
+
+ RMobilePhone::TMobilePhoneSecurityEvent ev(RMobilePhone::EICCTerminated);
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> evData(ev);
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data, 2);
+
+ iPhone.CancelAsyncRequest(EMobilePhoneNotifySecurityCapsChange);
+
+ User::WaitForRequest(requestStatus);
+
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2); // data, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-NTWS-MNSCC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::NotifySecurityCapsChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobilePhone::NotifySecurityCapsChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyPhoneSecurityFU::TestNotifySecurityCapsChange0004L()
+ {
+ 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(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobilePhone::NotifySecurityCapsChange
+ //-------------------------------------------------------------------------
+ // If this API is flow controlled by Etel or if this API is
+ // synchronous, remove this test completely.
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ TUint32 oldCaps;
+ iPhone.GetSecurityCaps(oldCaps);
+
+ TRequestStatus requestStatus1;
+ TUint32 caps1;
+ iPhone.NotifySecurityCapsChange(requestStatus1, caps1);
+
+ TRequestStatus requestStatus2;
+ TUint32 caps2;
+ phone2.NotifySecurityCapsChange(requestStatus2, caps2);
+
+ RMobilePhone::TMobilePhoneSecurityEvent ev(RMobilePhone::EICCTerminated);
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityEvent> evData(ev);
+ evData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobilePhoneNotifySecurityEvent, KErrNone, data);
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+
+
+ TUint32 capsToCompare(0);
+
+ if ( oldCaps & RMobilePhone::KCapsLockPhone )
+ {
+ capsToCompare |= RMobilePhone::KCapsLockPhone;
+ }
+
+ if ( oldCaps & RMobilePhone::KCapsAccessPhonePassword )
+ {
+ capsToCompare |= RMobilePhone::KCapsAccessPhonePassword;
+ }
+
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+ ASSERT_EQUALS(capsToCompare, caps1);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(capsToCompare, caps2);
+
+
+ AssertMockLtsyStatusL();
+
+ // Done !
+ CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this
+
+ }
+