--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsysecurityfu.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1630 @@
+// Copyright (c) 2008-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:
+//
+
+
+
+/**
+ @file The TEFUnit test suite for SecurityControl in the Common TSY.
+*/
+
+#include <etel.h>
+#include <etelmm.h>
+#include <et_clsvr.h>
+#include <ctsy/mmtsy_names.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include <test/tmockltsydata.h>
+#include <ctsy/serviceapi/gsmerror.h>
+#include <ctsy/ltsy/mltsydispatchsecurityinterface.h>
+#include "mockltsyindicatorids.h"
+#include <ctsy/ltsy/mltsydispatchsiminterface.h>
+#include <ctsy/rmmcustomapi.h>
+#include <ctsy/serviceapi/cmmcustomsecuritytsyconstants.h>
+#include <ctsy/ltsy/mltsydispatchcallcontrolinterface.h>
+#include "cctsysecurityfu.h"
+
+CTestSuite* CCTsySecurityFU::CreateSuiteL(const TDesC& aName)
+ {
+ SUB_SUITE;
+
+ //add use-case tests
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUseCase0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUseCase0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUseCase0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUseCase0004L);
+
+ //add other unit tests
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0010L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0015L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySecurityFU, TestUnit0016L);
+
+ END_SUITE;
+ }
+
+//
+// Use-case tests
+//
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UC0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetFdnSetting, RMobilePhone::VerifySecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::SetFdnSetting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsySecurityFU::TestUseCase0001L()
+ {
+ /*
+ * This test uses VerifySecurityCode with SetFdnSetting to get the SetFdnSetting sent to the LTSY
+ */
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus reqStatus, reqStatusNotif, reqStatusVerify;
+
+ // Prepare data for mockLtsy for the VerifySecurityCode.
+ // This mimics the scenario that Pin2 code is required to make SetFdnSetting complete successfully.
+ // Therefore we use VerifySecurityCode to supply the Pin2 code.
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin2;
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblockPwd");
+ 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 reqStatus2;
+ RMobilePhone::TMobilePhoneSecurityEvent secEventRes;
+ iMockLTSY.ExpectL(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId);
+ iPhone.NotifySecurityEvent(reqStatus2, secEventRes);
+
+ // Call the ipc for SetFdnSetting.
+ // Also call NotifyFdnStatusChange as this is triggered by CTSY when SetFdnSetting completes
+ RMobilePhone::TMobilePhoneFdnStatus fdnStatus(RMobilePhone::EFdnUnknown);
+ iPhone.NotifyFdnStatusChange(reqStatusNotif, fdnStatus);
+ RMobilePhone::TMobilePhoneFdnSetting fdnSetting(RMobilePhone::EFdnSetOff);
+ iPhone.SetFdnSetting(reqStatus, fdnSetting);
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+
+ // Send the ExpectL and CompleteL for VerifySecurityCode
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrGeneral);
+
+ // Call ipc for VerifySecurityCode
+ iPhone.VerifySecurityCode(reqStatusVerify, secCode, pwd, unblockPwd);
+
+ // Wait for VerifySecurityCode...
+ User::WaitForRequest(reqStatusVerify);
+ ASSERT_EQUALS(KErrGeneral, reqStatusVerify.Int());
+ AssertMockLtsyStatusL();
+
+ // Wait for SetFdnSetting...
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ iPhone.NotifySecurityEvent(reqStatus2, secEventRes);
+
+ iPhone.SetFdnSetting(reqStatus, fdnSetting);
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+
+ // Send the ExpectL and CompleteL for VerifySecurityCode
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrNone);
+
+ // Send ExpectL for SetFdnSetting
+ data.Close();
+ TMockLtsyData1<RMobilePhone::TMobilePhoneFdnSetting> setData(fdnSetting);
+ data.Close();
+ setData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchSimSetFdnSetting::KLtsyDispatchSimSetFdnSettingApiId, data, KErrNone);
+
+ // Call ipc for VerifySecurityCode
+ iPhone.VerifySecurityCode(reqStatusVerify, secCode, pwd, unblockPwd);
+
+ // Wait for VerifySecurityCode...
+ User::WaitForRequest(reqStatusVerify);
+ ASSERT_EQUALS(KErrNone, reqStatusVerify.Int());
+ AssertMockLtsyStatusL();
+
+ // Now send the CompleteL for SetFdnSetting since CTSY sends this ipc down to LTSY after completing VerifySecurityCode.
+ iMockLTSY.CompleteL(MLtsyDispatchSimSetFdnSetting::KLtsyDispatchSimSetFdnSettingApiId, KErrNone);
+
+ // Wait for SetFdnSetting...
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ User::WaitForRequest(reqStatusNotif);
+ ASSERT_EQUALS(KErrNone, reqStatusNotif.Int());
+ ASSERT_EQUALS(fdnStatus, RMobilePhone::EFdnNotActive);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UC0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyLockInfoChange, RMobilePhone::SetLockSetting
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::SetLockSetting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsySecurityFU::TestUseCase0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ 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);
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+
+ TRequestStatus status;
+
+ RMobilePhone::TMobilePhoneLock lock2 = RMobilePhone::ELockHiddenKey;//ELockUSimApp;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;
+ TDesC* passwordPtr = const_cast<TDesC*>(&KNullDesC);
+
+ TMockLtsyData3<RMobilePhone::TMobilePhoneLock,RMobilePhone::TMobilePhoneLockSetting,TDesC*> phoneLockData(lock2,lockSetting,passwordPtr);
+ phoneLockData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, KErrNone);
+
+ iPhone.SetLockSetting(status, lock2, lockSetting);
+ User::WaitForRequest(status);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, status.Int());
+
+ TMockLtsyData3<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting,
+ RMobilePhone::TMobilePhoneLock> lockInfoData(lockInfoV1.iStatus, lockInfoV1.iSetting, lock);
+ data.Close();
+ lockInfoData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(KMockLtsyDispatchSecurityNotifyLockInfoChangeIndId, KErrNone, data);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ //now test case where SetLockSetting() has a password send down, this involves doing a VerifySecurityCode(), thus
+ //the password is set to "\0" (this is for dispatcher coverage).
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin2;
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblockPwd");
+ RMobilePhone::TMobilePassword pwd(KPwd);
+ RMobilePhone::TMobilePassword unblockPwd(KUnblockPwd);
+
+
+ RMobilePhone::TCodeAndUnblockCode twoCodes;
+ twoCodes.iCode.Copy(KPwd);
+ twoCodes.iUnblockCode.Copy(KUnblockPwd);
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, RMobilePhone::TCodeAndUnblockCode> verifyData(secCode, twoCodes);
+ data.Close();
+ verifyData.SerialiseL(data);
+
+
+ // Send the ExpectL and CompleteL for VerifySecurityCode
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrNone);
+
+ // Call ipc for VerifySecurityCode
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+
+ // Wait for VerifySecurityCode...
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+
+
+ data.Close();
+ _LIT( KNullCharacter, "\0" );
+ passwordPtr = const_cast<TDesC*>(&KNullCharacter);
+ phoneLockData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, KErrNone);
+
+ iPhone.SetLockSetting(status, lock2, lockSetting);
+ User::WaitForRequest(status);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, status.Int());
+
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UC0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetLockSetting
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::SetLockSetting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsySecurityFU::TestUseCase0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus reqStatus, reqStatus2, reqStatusVerify;
+ RMobilePhone::TMobilePhoneSecurityEvent secEventRes;
+ iMockLTSY.ExpectL(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId);
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockICC;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;
+ iPhone.SetLockSetting(reqStatus2, lock, lockSetting);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin2;
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblockPwd");
+ 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);
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrAccessDenied);
+
+ iPhone.VerifySecurityCode(reqStatusVerify, secCode, pwd, unblockPwd);
+
+ User::WaitForRequest(reqStatusVerify);
+ ASSERT_EQUALS(KErrAccessDenied, reqStatusVerify.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrAccessDenied, reqStatus2.Int());
+
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+
+ iPhone.SetLockSetting(reqStatus2, lock, lockSetting);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ data.Close();
+ verifyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrNone);
+
+ RMobilePhone::TMobilePhoneLock lock2 = RMobilePhone::ELockICC;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting2 = RMobilePhone::ELockSetEnabled;
+ TDesC* passwordPtr = const_cast<TDesC*>(&KPwd);
+ TMockLtsyData3<RMobilePhone::TMobilePhoneLock,RMobilePhone::TMobilePhoneLockSetting,TDesC*> phoneLockData(lock2,lockSetting2,passwordPtr);
+ data.Close();
+ phoneLockData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, data);
+
+ iPhone.VerifySecurityCode(reqStatusVerify, secCode, pwd, unblockPwd);
+
+ User::WaitForRequest(reqStatusVerify);
+ ASSERT_EQUALS(KErrNone, reqStatusVerify.Int());
+
+ iMockLTSY.CompleteL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, KErrNone);
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UC0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::AbortSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::AbortSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsySecurityFU::TestUseCase0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin2;
+
+ _LIT(KPwd,"pwd");
+ _LIT(KUnblockPwd, "unblockPwd");
+ 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);
+
+ // Send the ExpectL and CompleteL for VerifySecurityCode
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data, KErrNone);
+
+ // Call ipc for VerifySecurityCode
+ iPhone.VerifySecurityCode(status, secCode, pwd, unblockPwd);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> secCodeData(secCode);
+ data.Close();
+ secCodeData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, KErrNone);
+
+ TInt res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrNone, res)
+ AssertMockLtsyStatusL();
+
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrAbort);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAbort, status.Int());
+ AssertMockLtsyStatusL();
+
+ // aborting SetLockSetting():
+ _LIT( KNullCharacter, "\0" );
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockHiddenKey;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;
+ TDesC* passwordPtr = const_cast<TDesC*>(&KNullCharacter);
+ TMockLtsyData3<RMobilePhone::TMobilePhoneLock,RMobilePhone::TMobilePhoneLockSetting,TDesC*> phoneLockData(lock,lockSetting,passwordPtr);
+ data.Close();
+ phoneLockData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, data);
+
+ iPhone.SetLockSetting(status, lock, lockSetting);
+
+ res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrNone, res)
+
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAbort, status.Int());
+ AssertMockLtsyStatusL();
+
+ // aborting SetFdnSetting():
+
+ RMobilePhone::TMobilePhoneFdnSetting fdnSetting(RMobilePhone::EFdnSetOff);
+ iPhone.SetFdnSetting(status, fdnSetting);
+
+ res = iPhone.AbortSecurityCode(secCode);
+ ASSERT_EQUALS(KErrNone, res)
+
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrAbort, status.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+//
+// Other unit tests
+//
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for VerifySecurityCode()
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::VerifySecurityCode()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0001L()
+ {
+ 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: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, 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(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrGeneral);
+ 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(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrNone);
+ 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(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrNone);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for SetPin1DisableNotSupported()
+@SYMTestPriority High
+@SYMTestActions Invokes SetPin1DisableNotSupported()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 dataComplete;
+ CleanupClosePushL(dataComplete);
+
+ TBool supported = EFalse;
+ TMockLtsyData1<TBool> ltsyData(supported);
+ dataComplete.Close();
+ ltsyData.SerialiseL(dataComplete);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ // send completion for calling SetPin1DisableNotSupported
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetPin1DisableSupported::KLtsyDispatchSecurityGetPin1DisableSupportedApiId, KErrNone, dataComplete);
+ User::WaitForRequest(mockLtsyStatus);
+
+ // SetLockSetting() should return an error now:
+ TRequestStatus status;
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockICC;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetDisabled;
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrGsm0707OperationNotAllowed, status.Int());
+
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ CleanupStack::PopAndDestroy(2, this); // dataComplete, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::AbortSecurityCode()
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::AbortSecurityCode()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0003L()
+ {
+ 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(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, 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(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, 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(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, 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(MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId, KErrNone);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetLockInfo()
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetLockInfo()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0004L()
+ {
+ 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(MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId, 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(MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId, dataExpect);
+
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;
+ RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting> phoneLockData(lockStatus, lockSetting);
+ phoneLockData.SerialiseL(dataComplete);
+
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId, 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(MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId, dataExpect);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId, 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(MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId, KErrNone, dataComplete);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ CleanupStack::PopAndDestroy(3); // dataComplete, dataExpect, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetSecurityCodeInfo()
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetSecurityCodeInfo()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0005L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 dataExpect;
+ CleanupClosePushL(dataExpect);
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword;
+ TInt remainingEntryAttempts = 4;
+ RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeV5;
+ TPckg<RMobilePhone::TMobilePhoneSecurityCodeInfoV5> pckgData(codeV5);
+
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> codeData(secCode);
+ codeData.SerialiseL(dataExpect);
+
+ TMockLtsyData2<RMobilePhone::TMobilePhoneSecurityCode, TInt> codeInfoData(secCode, remainingEntryAttempts);
+ codeInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId, 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(MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId, dataExpect);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId, 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(MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId, dataExpect);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId, KErrNone, data);
+ iPhone.GetSecurityCodeInfo(reqStatus, secCode, pckgData);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(remainingEntryAttempts, pckgData().iRemainingEntryAttempts)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::GetSecurityCodeInfo
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // dataExpect, data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyLockInfoChange()
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifyLockInfoChange()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ 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);
+
+ TMockLtsyData3<RMobilePhone::TMobilePhoneLockStatus, RMobilePhone::TMobilePhoneLockSetting,
+ RMobilePhone::TMobilePhoneLock> lockInfoData(lockInfoV1.iStatus, lockInfoV1.iSetting, lock);
+ lockInfoData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::NotifyLockInfoChange when result is not cached.
+ //-------------------------------------------------------------------------
+ iPhone.NotifyLockInfoChange(reqStatus, lock, pckgData);
+ iMockLTSY.CompleteL(KMockLtsyDispatchSecurityNotifyLockInfoChangeIndId, KErrNone, data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(lockInfoV1.iSetting,pckgData().iSetting)
+ ASSERT_EQUALS(lockInfoV1.iStatus,pckgData().iStatus)
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifySecurityEvent()
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifySecurityEvent()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0007L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ 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(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId);
+ iPhone.NotifySecurityEvent(reqStatus, secEventRes);
+ iMockLTSY.CompleteL(KMockLtsyDispatchSecurityNotifySecurityEventIndId, 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(KMockLtsyDispatchSecurityNotifySecurityEventIndId, 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(KMockLtsyDispatchSecurityNotifySecurityEventIndId, 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(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::SetLockSetting()
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::SetLockSetting()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0008L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus status;
+
+ RMobilePhone::TMobilePhoneLock lockB = RMobilePhone::ELockPhoneDevice;
+ RMobilePhone::TMobilePhoneLockSetting lockSettingB = RMobilePhone::ELockSetEnabled;
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ iPhone.SetLockSetting(status, lockB, lockSettingB);
+ iMockLTSY.CompleteL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, KErrGeneral);
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrGeneral, status.Int());
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::SetLockSetting
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, KErrNone);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::SetLockSetting when result is not cached.
+ //-------------------------------------------------------------------------
+ // data for ExpectL
+
+
+ RMobilePhone::TMobilePhoneLock lock = RMobilePhone::ELockHiddenKey;//ELockUSimApp;
+ RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;
+ TDesC* passwordPtr = const_cast<TDesC*>(&KNullDesC);
+
+ TMockLtsyData3<RMobilePhone::TMobilePhoneLock,RMobilePhone::TMobilePhoneLockSetting,TDesC*> phoneLockData(lock,lockSetting,passwordPtr);
+ phoneLockData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId, KErrNone);
+
+ iPhone.SetLockSetting(status, lock, lockSetting);
+ User::WaitForRequest(status);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, status.Int());
+
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for SetActivePin()
+@SYMTestPriority High
+@SYMTestActions Invokes SetActivePin()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0009L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMmCustomAPI customAPI;
+ OpenCustomApiLC(customAPI);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ MLtsyDispatchSimGetActiveIccApplicationType::TIccType type = MLtsyDispatchSimGetActiveIccApplicationType::EIccTypeSim3G;
+
+ TMockLtsyData1<MLtsyDispatchSimGetActiveIccApplicationType::TIccType> iccData(type);
+ data.Close();
+ iccData.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId, KErrNone, data);
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId);
+
+ RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin1;
+ TMockLtsyData1<RMobilePhone::TMobilePhoneSecurityCode> secCodeData(secCode);
+ data.Close();
+ secCodeData.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId, KErrNone, data);
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+
+ // verify currently active PIN:
+ RMobilePhone::TMobilePhoneSecurityCode code;
+ customAPI.GetActivePin(code);
+ ASSERT_EQUALS(RMobilePhone::ESecurityCodePin1, code);
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this); // data, customAPI, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0010
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckSecurityCode()
+@SYMTestPriority High
+@SYMTestActions Invokes RMmCustomAPI::CheckSecurityCode()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0010L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMmCustomAPI customAPI;
+ OpenCustomApiLC(customAPI);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ TRequestStatus requestStatus;
+ RMmCustomAPI::TSecurityCodeType type(RMmCustomAPI::ESecurityCodePin1);
+ DispatcherSecurity::TSecurityCodeId secCodeID = DispatcherSecurity::ESecCodePin;
+ RMobilePhone::TMobilePassword secCode;
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ TMockLtsyData2 <DispatcherSecurity::TSecurityCodeId, RMobilePhone::TMobilePassword> ltsyData(secCodeID, secCode);
+ ltsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, data, KErrNotSupported);
+
+ customAPI.CheckSecurityCode(requestStatus, type);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, data);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, KErrGeneral);
+
+ TMockLtsyData1 <DispatcherSecurity::TSecurityCodeId > ltsyData2(secCodeID);
+ ltsyData2.SerialiseL(data2);
+
+ // this is because HandleRequest(ECustomCheckSecurityCodeCancelIPC) is called when completing by error
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityCheckSecurityCodeCancel::KLtsyDispatchSecurityCheckSecurityCodeCancelApiId, data2);
+
+ customAPI.CheckSecurityCode(requestStatus, type);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMmCustomAPI::CheckSecurityCode when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, data);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, KErrNone);
+
+ customAPI.CheckSecurityCode(requestStatus, type);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMmCustomAPI::CheckSecurityCode
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, KErrNone);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // data2, data, customAPI, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DisablePhoneLock()
+@SYMTestPriority High
+@SYMTestActions Invokes RMmCustomAPI::DisablePhoneLock()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMmCustomAPI customAPI;
+ OpenCustomApiLC(customAPI);
+
+ _LIT(KPassword, "password");
+
+ TRequestStatus requestStatus;
+ RMobilePhone::TMobilePassword pswd(KPassword);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ TMockLtsyData1< RMobilePhone::TMobilePassword > ltsyData(pswd);
+ ltsyData.SerialiseL(expectData);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId, expectData, KErrNotSupported);
+
+ customAPI.DisablePhoneLock(requestStatus, pswd);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId, expectData);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId, KErrGeneral);
+
+ customAPI.DisablePhoneLock(requestStatus, pswd);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMmCustomAPI::DisablePhoneLock when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId, expectData);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId, KErrNone);
+
+ customAPI.DisablePhoneLock(requestStatus, pswd);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMmCustomAPI::DisablePhoneLock
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId, KErrNone);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // expectData, customAPI, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyCipheringInfoChange()
+@SYMTestPriority High
+@SYMTestActions Invokes RMmCustomAPI::NotifyCipheringInfoChange()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0012L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMmCustomAPI customAPI;
+ OpenCustomApiLC(customAPI);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMmCustomAPI::TCipheringInfo info;
+ RMmCustomAPI::TCipheringInfo completeInfo;
+ completeInfo.iIndStatus = ETrue;
+ completeInfo.iCiphStatus = ETrue;
+
+ TMockLtsyData1<RMmCustomAPI::TCipheringInfo > ltsyData(completeInfo);
+ ltsyData.SerialiseL(completeData);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMmCustomAPI::NotifyCipheringInfoChange when result is not cached.
+ //-------------------------------------------------------------------------
+ customAPI.NotifyCipheringInfoChange(requestStatus, info);
+ iMockLTSY.CompleteL(KLtsyDispatchSecurityNotifyCipheringInfoChangeApiId, KErrNone, completeData);
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ASSERT_EQUALS(completeInfo.iIndStatus, info.iIndStatus);
+ ASSERT_EQUALS(completeInfo.iCiphStatus, info.iCiphStatus);
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMmCustomAPI::NotifyCipheringInfoChange
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(KLtsyDispatchSecurityNotifyCipheringInfoChangeApiId, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ CleanupStack::PopAndDestroy(3, this); // completeData, customAPI, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCipheringInfo()
+@SYMTestPriority High
+@SYMTestActions Invokes RMmCustomAPI::GetCipheringInfo()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0013L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMmCustomAPI customAPI;
+ OpenCustomApiLC(customAPI);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RBuf8 completeData2;
+ CleanupClosePushL(completeData2);
+
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+ RMmCustomAPI::TCipheringInfo info;
+
+ TBool indReq(ETrue);
+ TMockLtsyData1<TBool > ltsyData(indReq);
+ ltsyData.SerialiseL(completeData);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId, KErrNotSupported);
+ customAPI.GetCipheringInfo(requestStatus, info);
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId, KErrGeneral, completeData);
+ customAPI.GetCipheringInfo(requestStatus, info);
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMmCustomAPI::GetCipheringInfo when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ RMmCustomAPI::TCipheringInfo ciphInfo;
+ ciphInfo.iCiphStatus = ETrue;
+
+ TMockLtsyData1<RMmCustomAPI::TCipheringInfo > ltsyData2(ciphInfo);
+ ltsyData2.SerialiseL(completeData2);
+
+ iMockLTSY.CompleteL(KLtsyDispatchSecurityNotifyCipheringInfoChangeApiId, KErrNone, completeData2);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId, KErrNone, completeData);
+ customAPI.GetCipheringInfo(requestStatus, info);
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ASSERT_EQUALS(indReq, info.iIndStatus);
+ ASSERT_EQUALS(ciphInfo.iCiphStatus, info.iCiphStatus);
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMmCustomAPI::GetCipheringInfo
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ CleanupStack::PopAndDestroy(4, this); // completeData2, completeData, customAPI, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::IsBlocked()
+@SYMTestPriority High
+@SYMTestActions Invokes RMmCustomAPI::IsBlocked()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsySecurityFU::TestUnit0014L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMmCustomAPI customAPI;
+ OpenCustomApiLC(customAPI);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RMmCustomAPI::TSecurityCodeType type(RMmCustomAPI::ESecurityCodePin1);
+ TBool result;
+
+ DispatcherSecurity::TSecurityCodeId secCodeID = DispatcherSecurity::ESecCodePin;
+
+ TMockLtsyData1 <DispatcherSecurity::TSecurityCodeId > ltsyData(secCodeID);
+ ltsyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId, data, KErrNotSupported);
+
+ TInt ret = customAPI.IsBlocked(type, result);
+
+ ASSERT_EQUALS(KErrNotSupported, ret);
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ TBool compResult(ETrue);
+ TMockLtsyData1 <TBool> ltsyData2(compResult);
+ ltsyData2.SerialiseL(completeData);
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId, data);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId, KErrGeneral, completeData);
+
+ ret = customAPI.IsBlocked(type, result);
+
+ ASSERT_EQUALS(KErrGeneral, ret);
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMmCustomAPI::IsBlocked when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId, data);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId, KErrNone, completeData);
+
+ ret = customAPI.IsBlocked(type, result);
+
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(compResult, result);
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMmCustomAPI::IsBlocked
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId, KErrNone, completeData);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // completeData, data, customAPI, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0015
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for CompleteNotifySecurityReady()
+@SYMTestPriority High
+@SYMTestActions Invokes CompleteNotifySecurityReady()
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsySecurityFU::TestUnit0015L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT(KPwd,"12345");
+ _LIT(KUnblockPwd, "54321");
+
+ // 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);
+
+ //-------------------------------------------------------------------------
+ //
+ // RMobilePhone::VerifySecurityCode
+ //-------------------------------------------------------------------------
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(KMockLtsyDispatchSecurityBootNotifySecurityReadyIndId, KErrNone);
+ User::WaitForRequest(mockLtsyStatus);
+
+ iMockLTSY.ExpectL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, data);
+ iMockLTSY.CompleteL(MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId, KErrNone);
+ iPhone.VerifySecurityCode(reqStatus, secCode, pwd, unblockPwd);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-SECURITY-UN0016
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::CheckSecurityCode
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMmCustomAPI::CheckSecurityCode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsySecurityFU::TestUnit0016L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMmCustomAPI customAPI;
+ OpenCustomAPILC(customAPI, iPhone);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ TRequestStatus requestStatus;
+ RMmCustomAPI::TSecurityCodeType type(RMmCustomAPI::ESecurityCodePin1);
+ DispatcherSecurity::TSecurityCodeId secCodeID = DispatcherSecurity::ESecCodePin;
+ RMobilePhone::TMobilePassword secCode;
+
+ TMockLtsyData2 <DispatcherSecurity::TSecurityCodeId, RMobilePhone::TMobilePassword> ltsyData(secCodeID, secCode);
+ ltsyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test A: Cancelling of RMmCustomAPI::CheckSecurityCode
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, data);
+ customAPI.CheckSecurityCode(requestStatus, type);
+
+ TMockLtsyData1 <DispatcherSecurity::TSecurityCodeId > ltsyData2(secCodeID);
+ ltsyData2.SerialiseL(data2);
+
+ iMockLTSY.ExpectL( MLtsyDispatchSecurityCheckSecurityCodeCancel::KLtsyDispatchSecurityCheckSecurityCodeCancelApiId, data2);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityCheckSecurityCodeCancel::KLtsyDispatchSecurityCheckSecurityCodeCancelApiId, KErrNone);
+ iMockLTSY.CompleteL( MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId, KErrCancel);
+
+ customAPI.CancelAsyncRequest(ECustomCheckSecurityCodeIPC);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+// Helper methods
+void CCTsySecurityFU::OpenCustomAPILC(RMmCustomAPI& aCustomAPI, RMobilePhone& aPhone, TBool aExpectNeeded)
+ {
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ if(aExpectNeeded)
+ {
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId);
+ }
+
+ TInt errorCode = aCustomAPI.Open(aPhone);
+ ASSERT_EQUALS(KErrNone, errorCode);
+ CleanupStack::PopAndDestroy (&data);
+ CleanupClosePushL(aCustomAPI);
+
+ }