diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsysimfu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsysimfu.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1958 @@ +// 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 SimControl in the Common TSY. +*/ + +#include "cctsysimfu.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "mockltsyindicatorids.h" + +#include +#include + +CTestSuite* CCTsySimFU::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + + //add use-case tests + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUseCase0001L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUseCase0002L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUseCase0003L); + + //add other unit tests + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0001L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0002L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0003L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0004L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0005L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0006L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0007L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0008L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0009L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0010L); + + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0011L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0012L); + + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0013L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0014L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0015L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0016L); + ADD_TEST_STEP_ISO_CPP(CCTsySimFU, TestUnit0017L); + + END_SUITE; + } + + +// +// Use-case tests +// + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UC0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for get, set and notify for MWIS +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::NotifyIccMessageWaitingIndicatorsChange, RMobilePhone::GetIccMessageWaitingIndicators, RMobilePhone::SetIccMessageWaitingIndicators +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySimFU::TestUseCase0001L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + /* + * NotifyIccMessageWaitingIndicatorsChange + */ + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + RMobilePhone::TMobilePhoneMessageWaitingV1 mwiRet; + RMobilePhone::TMobilePhoneMessageWaitingV1Pckg mwiRetPckg(mwiRet); + iPhone.NotifyIccMessageWaitingIndicatorsChange(requestStatus, mwiRetPckg); + + // Prepare the NotifyIccMessageWaitingIndicatorsChange data for CompleteL + RMobilePhone::TMobilePhoneMessageWaitingV1 mwiNotifComplete; + mwiNotifComplete.iAuxVoiceMsgs = 1; + mwiNotifComplete.iDataMsgs = 2; + mwiNotifComplete.iDisplayStatus = 3; + mwiNotifComplete.iEmailMsgs = 4; + mwiNotifComplete.iFaxMsgs = 5; + mwiNotifComplete.iOtherMsgs = 6; + mwiNotifComplete.iVoiceMsgs = 7; + + TMockLtsyData1 mockMwisData1(mwiNotifComplete); + + // Send the CompleteL to MockLtsy + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + data.Close(); + mockMwisData1.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSimNotifyIccMessageWaitingIndicatorsChangeIndId, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // Check completion of api + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + // Check returned data + ASSERT_EQUALS(mwiRet.iAuxVoiceMsgs, mwiNotifComplete.iAuxVoiceMsgs); + ASSERT_EQUALS(mwiRet.iDataMsgs, mwiNotifComplete.iDataMsgs); + ASSERT_EQUALS(mwiRet.iDisplayStatus, mwiNotifComplete.iDisplayStatus); + ASSERT_EQUALS(mwiRet.iEmailMsgs, mwiNotifComplete.iEmailMsgs); + ASSERT_EQUALS(mwiRet.iFaxMsgs, mwiNotifComplete.iFaxMsgs); + ASSERT_EQUALS(mwiRet.iOtherMsgs, mwiNotifComplete.iOtherMsgs); + ASSERT_EQUALS(mwiRet.iVoiceMsgs, mwiNotifComplete.iVoiceMsgs); + + /* + * SetIccMessageWaitingIndicators. + * Also test NotifyIccMessageWaitingIndicatorsChange triggered + * from a client set when the SetIccMessageWaitingIndicators data values are different to previous values. + */ + + // Post notification + TRequestStatus requestStatusNotif; + iPhone.NotifyIccMessageWaitingIndicatorsChange(requestStatusNotif, mwiRetPckg); + + // Prepare ExpectL data for the Set + RMobilePhone::TMobilePhoneMessageWaitingV1 mwiSet; + RMobilePhone::TMobilePhoneMessageWaitingV1Pckg mwiSetRetPckg(mwiSet); + // Use values for setting the data that is different to what was used before, so that + // Ctsy detects a change and hence issues a notification. + // (Not each of the fields have necessarily to be different). + mwiSet.iAuxVoiceMsgs = ++mwiNotifComplete.iAuxVoiceMsgs; + mwiSet.iDataMsgs = ++mwiNotifComplete.iDataMsgs; + mwiSet.iDisplayStatus = ++mwiNotifComplete.iDisplayStatus; + mwiSet.iEmailMsgs = ++mwiNotifComplete.iEmailMsgs; + mwiSet.iFaxMsgs = ++mwiNotifComplete.iFaxMsgs; + mwiSet.iOtherMsgs = ++mwiNotifComplete.iOtherMsgs; + mwiSet.iVoiceMsgs = ++mwiNotifComplete.iVoiceMsgs; + + TMockLtsyData1setData(mwiSet); + data.Close(); + setData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSimSetIccMessageWaitingIndicators::KLtsyDispatchSimSetIccMessageWaitingIndicatorsApiId, data, KErrNone); + iMockLTSY.CompleteL(MLtsyDispatchSimSetIccMessageWaitingIndicators::KLtsyDispatchSimSetIccMessageWaitingIndicatorsApiId, KErrNone); + + // Call api + TRequestStatus requestStatusSet; + iPhone.SetIccMessageWaitingIndicators(requestStatusSet, mwiSetRetPckg); + User::WaitForRequest(requestStatusSet); + ASSERT_EQUALS(KErrNone, requestStatusSet.Int()); + AssertMockLtsyStatusL(); + + // Wait for notificaion + User::WaitForRequest(requestStatusNotif); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatusNotif.Int()); + + /* + * GetIccMessageWaitingIndicators + */ + + TRequestStatus requestStatusGet; + + // Send the ExpectL + iMockLTSY.ExpectL(MLtsyDispatchSimGetIccMessageWaitingIndicators::KLtsyDispatchSimGetIccMessageWaitingIndicatorsApiId); + + // Prepare data for the mockLtsy's CompleteL + RMobilePhone::TMobilePhoneMessageWaitingV1 mwiComp; + mwiComp.iDisplayStatus = 0xff; + mwiComp.iVoiceMsgs = 0x01; + mwiComp.iAuxVoiceMsgs = 0x02; + mwiComp.iDataMsgs = 0x03; + mwiComp.iFaxMsgs = 0x04; + mwiComp.iEmailMsgs = 0x05; + mwiComp.iOtherMsgs = 0x06; + TMockLtsyData1 mwisdCompData(mwiComp); + data.Close(); + mwisdCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetIccMessageWaitingIndicators::KLtsyDispatchSimGetIccMessageWaitingIndicatorsApiId, KErrNone, data); + + // Now call the ipc + RMobilePhone::TMobilePhoneMessageWaitingV1 mwiGet; + RMobilePhone::TMobilePhoneMessageWaitingV1Pckg mwiGetPckg(mwiGet); + iPhone.GetIccMessageWaitingIndicators(requestStatusGet, mwiGetPckg); + + User::WaitForRequest(requestStatusGet); + ASSERT_EQUALS(KErrNone, requestStatusGet.Int()); + AssertMockLtsyStatusL(); + + // Check returned data + ASSERT_EQUALS(mwiGet.iAuxVoiceMsgs, mwiComp.iAuxVoiceMsgs); + ASSERT_EQUALS(mwiGet.iDataMsgs, mwiComp.iDataMsgs); + ASSERT_EQUALS(mwiGet.iDisplayStatus, mwiComp.iDisplayStatus); + ASSERT_EQUALS(mwiGet.iEmailMsgs, mwiComp.iEmailMsgs); + ASSERT_EQUALS(mwiGet.iFaxMsgs, mwiComp.iFaxMsgs); + ASSERT_EQUALS(mwiGet.iOtherMsgs, mwiComp.iOtherMsgs); + ASSERT_EQUALS(mwiGet.iVoiceMsgs, mwiComp.iVoiceMsgs); + + data.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UC0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for APN Control List operations +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetAPNControlListServiceStatus , RMobilePhone::NotifyAPNControlListServiceStatusChange, RMobilePhone::SetAPNControlListServiceStatus +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySimFU::TestUseCase0002L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus mockLtsyStatus; + + /* + * GetAPNControlListServiceStatus + */ + + TRequestStatus requestStatusGet; + + // Send the ExpectL + iMockLTSY.ExpectL(MLtsyDispatchSimGetApnControlListServiceStatus::KLtsyDispatchSimGetApnControlListServiceStatusApiId); + + // Prepare data for the mockLtsy's CompleteL + RMobilePhone::TAPNControlListServiceStatus statusComp = RMobilePhone::EAPNControlListServiceDisabled; + + TMockLtsyData1 statusCompData(statusComp); + data.Close(); + statusCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetApnControlListServiceStatus::KLtsyDispatchSimGetApnControlListServiceStatusApiId, KErrNone, data); + + // Now call the ipc + RMobilePhone::TAPNControlListServiceStatus statusGet; + iPhone.GetAPNControlListServiceStatus(requestStatusGet, statusGet); + + User::WaitForRequest(requestStatusGet); + ASSERT_EQUALS(KErrNone, requestStatusGet.Int()); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(statusGet, statusComp); + + /* + * Set the APN Control List status to Enabled using SetAPNControlListServiceStatus and check for update using + * NotifyAPNControlListServiceStatusChange. + */ + + // Post notification + TRequestStatus requestStatusNotif; + RMobilePhone::TAPNControlListServiceStatus statusNotif; + iPhone.NotifyAPNControlListServiceStatusChange(requestStatusNotif, statusNotif); + + // Prepare ExpectL data for the Set + RMobilePhone::TAPNControlListServiceStatus statusSet = RMobilePhone::EAPNControlListServiceEnabled; + + TMockLtsyData1setData(statusSet); + data.Close(); + setData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSimSetApnControlListServiceStatus::KLtsyDispatchSimSetApnControlListServiceStatusApiId, data, KErrNone); + iMockLTSY.CompleteL(MLtsyDispatchSimSetApnControlListServiceStatus::KLtsyDispatchSimSetApnControlListServiceStatusApiId, KErrNone); + + // Call api + TRequestStatus requestStatusSet; + iPhone.SetAPNControlListServiceStatus(requestStatusSet, statusSet); + User::WaitForRequest(requestStatusSet); + ASSERT_EQUALS(KErrNone, requestStatusSet.Int()); + AssertMockLtsyStatusL(); + + // Prepare CompleteL data for the notification (will be same as that used in the Set). + RMobilePhone::TAPNControlListServiceStatus statusNotifComp = statusSet; + TMockLtsyData1 statusNotifCompData1(statusNotifComp); + data.Close(); + statusNotifCompData1.SerialiseL(data); + // Send CompleteL for the notification + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(KMockLtsyDispatchSimNotifyApnControlListServiceStatusChangeIndId, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + // Check completion of notification + User::WaitForRequest(requestStatusNotif); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatusNotif.Int()); + + // Check data returned in the notification same as date used in the Set. + ASSERT_EQUALS(statusNotif, statusSet); + + data.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UC0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for APN list operations +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::AppendAPNName, RMobilePhone::DeleteAPNName, RMobilePhone::GetAPNname, RMobilePhone::EnumerateAPNEntries, RMobilePhone::NotifyAPNListChanged +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySimFU::TestUseCase0003L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + /* + * EnumerateAPNEntries + */ + + TRequestStatus requestStatusEnmrt; + + // Prepare ExpectL and CompleteL data + iMockLTSY.ExpectL(MLtsyDispatchSimEnumerateApnEntries::KLtsyDispatchSimEnumerateApnEntriesApiId); + + const TUint32 KNumAPNListEntries = 5; + TUint32 enmrtComp = KNumAPNListEntries; + TMockLtsyData1 enmrtCompData(enmrtComp); + data.Close(); + enmrtCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimEnumerateApnEntries::KLtsyDispatchSimEnumerateApnEntriesApiId, KErrNone, data); + + // Call ipc + TUint32 enmrtRet; + iPhone.EnumerateAPNEntries(requestStatusEnmrt, enmrtRet); + User::WaitForRequest(requestStatusEnmrt); + ASSERT_EQUALS(KErrNone, requestStatusEnmrt.Int()); + AssertMockLtsyStatusL(); + + // Check returned data + ASSERT_EQUALS(enmrtComp, enmrtRet); + + data.Close(); + AssertMockLtsyStatusL(); + + /* + * GetAPNname + */ + + TRequestStatus requestStatusGet; + + // Prepare ExpectL and CompleteL data + TUint32 index = 69; + TMockLtsyData1 indexData(index); + indexData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimGetApnName::KLtsyDispatchSimGetApnNameApiId, data, KErrNone); + + RMobilePhone::TAPNEntryV3 apnEntryComp; + const TBuf8 KApnName(_L8("Mobile Network access point 1")); + apnEntryComp.iApn = KApnName; + TMockLtsyData1 apnEntryData(apnEntryComp); + data.Close(); + apnEntryData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetApnName::KLtsyDispatchSimGetApnNameApiId, KErrNone, data); + + // Call ipc + RMobilePhone::TAPNEntryV3 apnEntryGet; + RMobilePhone::TAPNEntryV3Pckg apnEntryGetPckg(apnEntryGet); + iPhone.GetAPNname(requestStatusGet, index, apnEntryGetPckg); + User::WaitForRequest(requestStatusGet); + ASSERT_EQUALS(KErrNone, requestStatusGet.Int()); + AssertMockLtsyStatusL(); + + // Check returned data + ASSERT_EQUALS(apnEntryGet.iApn, apnEntryComp.iApn); + + data.Close(); + AssertMockLtsyStatusL(); + + /* + * DeleteAPNName and notify of change to APN list using NotifyAPNListChanged + */ + + // Post notification + TRequestStatus requestStatusNotif; + iPhone.NotifyAPNListChanged(requestStatusNotif); + + // Prepare ExpectL and CompleteL data for the delete + TUint32 indexDel = 49; + TMockLtsyData1 indexDelData(indexDel); + indexDelData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimDeleteApnName::KLtsyDispatchSimDeleteApnNameApiId, data, KErrNone); + + iMockLTSY.CompleteL(MLtsyDispatchSimDeleteApnName::KLtsyDispatchSimDeleteApnNameApiId, KErrNone); + + // Now call the ipc + TRequestStatus requestStatusDel; + iPhone.DeleteAPNName(requestStatusDel, indexDel); + User::WaitForRequest(requestStatusDel); + ASSERT_EQUALS(KErrNone, requestStatusDel.Int()); + AssertMockLtsyStatusL(); + + // Send CompleteL for noticn + iMockLTSY.CompleteL(KMockLtsyDispatchSimNotifyApnListChangeIndId , KErrNone); + User::WaitForRequest(requestStatusNotif); + ASSERT_EQUALS(KErrNone, requestStatusNotif.Int()); + + data.Close(); + AssertMockLtsyStatusL(); + + /* + * AppendAPNName + */ + + // Prepare ExpectL and CompleteL data for the append + const TBuf8 KApnNameAppend(_L8("New Mobile Network access point 2")); + RMobilePhone::TAPNEntryV3 entryExp; + entryExp.iApn = KApnNameAppend; + TMockLtsyData1 entryExpData(entryExp); + data.Close(); + entryExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimAppendApnName::KLtsyDispatchSimAppendApnNameApiId, data, KErrNone); + iMockLTSY.CompleteL(MLtsyDispatchSimAppendApnName::KLtsyDispatchSimAppendApnNameApiId, KErrNone); + + // Now call the ipc + TRequestStatus requestStatusApp; + RMobilePhone::TAPNEntryV3Pckg entryAppPckg(entryExp); + iPhone.AppendAPNName(requestStatusApp, entryAppPckg); + User::WaitForRequest(requestStatusApp); + ASSERT_EQUALS(KErrNone, requestStatusApp.Int()); + AssertMockLtsyStatusL(); + + data.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + + +// +// Other unit tests +// + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::GetServiceTable +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetServiceTable +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0001L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + RMobilePhone::TMobilePhoneServiceTableV1 simServiceTable; + simServiceTable.iServices1To8 = 0xFF; + simServiceTable.iServices9To16 = 0xFF; + simServiceTable.iServices17To24= 0xFF; + simServiceTable.iServices25To32= 0xFF; + simServiceTable.iServices33To40= 0xFF; + simServiceTable.iServices41To48= 0xFF; + simServiceTable.iServices49To56= 0xFF; + + OpenPhoneL(simServiceTable); + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + RBuf8 data; + CleanupClosePushL(data); + + RMobilePhone::TMobilePhoneServiceTableV1 tbData; + RMobilePhone::TMobilePhoneServiceTableV1Pckg pkg(tbData); + + //test getting service table when TSY not ready (ICC type is unknown) + + TRequestStatus reqStat; + iPhone.GetServiceTable(reqStat, RMobilePhone::EUSIMServiceTable, pkg); + User::WaitForRequest(reqStat); + ASSERT_EQUALS(reqStat.Int(), KErrMMEtelWrongMode); + + //now get the ICC type. We do this by invoking NotifySecurityEvent - why I don't know! + iMockLTSY.ExpectL(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId); + MLtsyDispatchSimGetActiveIccApplicationType::TIccType type = MLtsyDispatchSimGetActiveIccApplicationType::EIccTypeSim3G; + TMockLtsyData1 retIccType(type); + retIccType.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetActiveIccApplicationType::KLtsyDispatchSimGetActiveIccApplicationTypeApiId,KErrNone,data, 0); + + iMockLTSY.ExpectL(MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId); + + RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePin1; + TMockLtsyData1 secCodeData(secCode); + data.Close(); + secCodeData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId, KErrNone, data); + + TRequestStatus reqStat2; + RMobilePhone::TMobilePhoneSecurityEvent event(RMobilePhone::EUniversalPukVerified); + iPhone.NotifySecurityEvent(reqStat2, event); + + User::WaitForRequest(mockLtsyStatus); + iPhone.CancelAsyncRequest(EMobilePhoneNotifySecurityEvent); + + User::After(5000000); // A delay is required by MockSY when being tested on hardware. + + + //test getting cached service table + + iPhone.GetServiceTable(reqStat, RMobilePhone::ESIMServiceTable, pkg); + User::WaitForRequest(reqStat); + ASSERT_EQUALS(reqStat.Int(), KErrNone); + ASSERT_EQUALS(tbData.iServices1To8,simServiceTable.iServices1To8); + ASSERT_EQUALS(tbData.iServices9To16,simServiceTable.iServices9To16); + ASSERT_EQUALS(tbData.iServices17To24,simServiceTable.iServices17To24); + ASSERT_EQUALS(tbData.iServices25To32,simServiceTable.iServices25To32); + ASSERT_EQUALS(tbData.iServices33To40,simServiceTable.iServices33To40); + ASSERT_EQUALS(tbData.iServices41To48,simServiceTable.iServices41To48); + ASSERT_EQUALS(tbData.iServices49To56,simServiceTable.iServices49To56); + + //finally test successful retrieval of service table + + RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::EUSIMServiceTable; + TMockLtsyData1 serviceTableData(serviceTable); + data.Close(); + serviceTableData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data); + + RMobilePhone::TMobilePhoneServiceTableV1 serviceTableResult; + serviceTableResult.iServices1To8 = 0xFF; + serviceTableResult.iServices9To16 = 0xFF; + serviceTableResult.iServices17To24= 0xFF; + serviceTableResult.iServices25To32= 0xFF; + serviceTableResult.iServices33To40= 0xFF; + serviceTableResult.iServices41To48= 0xFF; + serviceTableResult.iServices49To56= 0xFF; + + TMockLtsyData1 serviceTableResultData(serviceTableResult); + data.Close(); + serviceTableResultData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId,KErrNone,data,0); + + iPhone.GetServiceTable(reqStat, RMobilePhone::EUSIMServiceTable, pkg); + User::WaitForRequest(reqStat); + ASSERT_EQUALS(reqStat.Int(), KErrNone); + ASSERT_EQUALS(tbData.iServices1To8, serviceTableResult.iServices1To8); + ASSERT_EQUALS(tbData.iServices9To16, serviceTableResult.iServices9To16); + ASSERT_EQUALS(tbData.iServices17To24, serviceTableResult.iServices17To24); + ASSERT_EQUALS(tbData.iServices25To32, serviceTableResult.iServices25To32); + ASSERT_EQUALS(tbData.iServices33To40, serviceTableResult.iServices33To40); + ASSERT_EQUALS(tbData.iServices41To48, serviceTableResult.iServices41To48); + ASSERT_EQUALS(tbData.iServices49To56, serviceTableResult.iServices49To56); + + +#ifdef EMULATOR_ONLY + //test cancel + + data.Close(); + serviceTableData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data); + //no complete as testing cancel + + iPhone.GetServiceTable(reqStat, RMobilePhone::EUSIMServiceTable, pkg); + iPhone.CancelAsyncRequest(EMobilePhoneGetServiceTable); + User::WaitForRequest(reqStat); + ASSERT_EQUALS(KErrCancel, reqStat.Int()); +#endif // EMULATOR_ONLY + + data.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::ChangeSecurityCode +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::ChangeSecurityCode +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0002L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + _LIT(KOldPwd,"oldPswd"); + _LIT(KNewPwd,"newPswd"); + RMobilePhone::TMobilePhonePasswordChangeV1 pwdChange; + pwdChange.iNewPassword = KNewPwd; + pwdChange.iOldPassword = KOldPwd; + + // Choose Phone Device Lock + RMobilePhone::TMobilePhoneSecurityCode secCode = RMobilePhone::ESecurityCodePhonePassword; + + // Prepare Mock Ltsy data for the ExpectL + TMockLtsyData2 pwdData(secCode, pwdChange); + pwdData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSimChangeSecurityCode::KLtsyDispatchSimChangeSecurityCodeApiId, data); + + // The Mock Ltsy CompleteL doesn't require data + iMockLTSY.CompleteL(MLtsyDispatchSimChangeSecurityCode::KLtsyDispatchSimChangeSecurityCodeApiId, KErrNone); + + // Call the API + iPhone.ChangeSecurityCode(reqStatus, secCode, pwdChange); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + data.Close(); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::GetSubscriberId +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetSubscriberId +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0003L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + _LIT8 (KIMSI8, "012012012012999"); + _LIT16(KIMSI16, "012012012012999"); + + // Send the ExpectL + iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId); + + // Prepare data for the mockLtsy's CompleteL + // Note the CTSY expects the data in 8-bit format. + TBuf8 idComp(KIMSI8); + TMockLtsyData1 > idCompData(idComp); + + data.Close(); + idCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data); + + // Now call the ipc + RMobilePhone::TMobilePhoneSubscriberId idGet; + iPhone.GetSubscriberId(reqStatus, idGet); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + ASSERT_TRUE(idGet == KIMSI16); // ASSERT_EQUALS will not work here + + data.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::GetCustomerServiceProfile +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetCustomerServiceProfile +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + // Send the ExpectL + iMockLTSY.ExpectL(MLtsyDispatchSimGetCustomerServiceProfile::KLtsyDispatchSimGetCustomerServiceProfileApiId); + + // Prepare data for the mockLtsy's CompleteL + RMobilePhone::TMobilePhoneCspFileV1 cspComp; + cspComp.iCallOfferingServices = 0x01; + cspComp.iCallRestrictionServices = 0x02; + cspComp.iOtherSuppServices = 0x03; + cspComp.iCallCompletionServices = 0x04; + cspComp.iTeleservices = 0x05; + cspComp.iCphsTeleservices = 0x06; + cspComp.iCphsFeatures = 0x07; + cspComp.iNumberIdentServices = 0x08; + cspComp.iPhase2PlusServices = 0x09; + cspComp.iValueAddedServices = 0x0A; + TMockLtsyData1 cspCompData(cspComp); + data.Close(); + cspCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetCustomerServiceProfile::KLtsyDispatchSimGetCustomerServiceProfileApiId, KErrNone, data); + + // Now call the ipc + RMobilePhone::TMobilePhoneCspFileV1 cspGet; + RMobilePhone::TMobilePhoneCspFileV1Pckg cspGetPckg(cspGet); + iPhone.GetCustomerServiceProfile(reqStatus, cspGetPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(cspComp.iCallOfferingServices, cspGet.iCallOfferingServices); + ASSERT_EQUALS(cspComp.iCallRestrictionServices, cspGet.iCallRestrictionServices); + ASSERT_EQUALS(cspComp.iOtherSuppServices, cspGet.iOtherSuppServices); + ASSERT_EQUALS(cspComp.iCallCompletionServices, cspGet.iCallCompletionServices); + ASSERT_EQUALS(cspComp.iTeleservices, cspGet.iTeleservices); + ASSERT_EQUALS(cspComp.iCphsTeleservices, cspGet.iCphsTeleservices); + ASSERT_EQUALS(cspComp.iCphsFeatures, cspGet.iCphsFeatures); + ASSERT_EQUALS(cspComp.iNumberIdentServices, cspGet.iNumberIdentServices); + ASSERT_EQUALS(cspComp.iPhase2PlusServices, cspGet.iPhase2PlusServices); + ASSERT_EQUALS(cspComp.iValueAddedServices, cspGet.iValueAddedServices); + + data.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for RMobilePhone::SetFdnSetting, RMobilePhone::VerifySecurityCode +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::SetFdnSetting +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0005L() + { + /* + * This test uses VerifySecurityCode with SetFdnSetting to get the SetFdnSetting sent to the LTSY + */ + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus mockLtsyStatus; + iMockLTSY.NotifyTerminated(mockLtsyStatus); + + 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 verifyData(secCode, twoCodes); + verifyData.SerialiseL(data); + + // 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); + + // 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 setData(fdnSetting); + data.Close(); + setData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSetFdnSetting::KLtsyDispatchSimSetFdnSettingApiId, data, KErrGeneral); + + // 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); + + data.Close(); + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for a Sim Refresh indicator from teh LTSY +@SYMTestPriority High +@SYMTestActions Invokes SIM Refresh IPC +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0006L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + RBuf8 data; + CleanupClosePushL(data); + + OpenPhoneL(); + + /****************************Nothing to Refresh***********************************************/ + + //KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline + TUint16 refreshFileList = 0; + + TMockLtsyData1 refreshFileListData(refreshFileList); + refreshFileListData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data); + data.Close(); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId); + + // Prepare data for the mockLtsy's CompleteL Note the CTSY expects the data in 8-bit format. + _LIT8 (KIMSI8, "012012012012999"); + TBuf8 idComp(KIMSI8); + TMockLtsyData1 > idCompData(idComp); + idCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data); + data.Close(); + + WaitForMockLTSYTerminated(); + + AssertMockLtsyStatusL(); + + /****************************Service Table Refresh***********************************************/ + + //KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline + refreshFileList = KCacheServiceTable; + + refreshFileListData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data); + data.Close(); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId); + + idCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data); + data.Close(); + + + RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::ESIMServiceTable; + TMockLtsyData1 serviceTableData(serviceTable); + serviceTableData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data); + data.Close(); + + RMobilePhone::TMobilePhoneServiceTableV1 serviceTableResult; + serviceTableResult.iServices1To8 = 0xFF; + serviceTableResult.iServices9To16 = 0xFF; + serviceTableResult.iServices17To24= 0xFF; + serviceTableResult.iServices25To32= 0xFF; + serviceTableResult.iServices33To40= 0xFF; + serviceTableResult.iServices41To48= 0xFF; + serviceTableResult.iServices49To56= 0xFF; + TMockLtsyData1 serviceTableResultData(serviceTableResult); + serviceTableResultData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId,KErrNone,data,0); + data.Close(); + + + TInt error = KErrNone; + TMockLtsyData1 simRefreshDoneExpLtsyData(error); + simRefreshDoneExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data); + data.Close(); + + WaitForMockLTSYTerminated(); + + AssertMockLtsyStatusL(); + + /****************************ALS Line Refresh***********************************************/ + + //KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline + refreshFileList = KCacheALSline; + + refreshFileListData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data); + data.Close(); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId); + + idCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data); + data.Close(); + + error = 0; //CTSY sends down 0 - EFalse, (No Read Error) see CMmPhoneTsy::ResetMEAlsInfo + simRefreshDoneExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data); + data.Close(); + + WaitForMockLTSYTerminated(); + + AssertMockLtsyStatusL(); + + /****************************Service Table Refresh && ALS Line Refresh*************************************/ + + //KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline + refreshFileList = KCacheServiceTable | KCacheALSline; + + refreshFileListData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data); + data.Close(); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId); + + idCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data); + data.Close(); + + serviceTableData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId, data); + data.Close(); + + serviceTableResultData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetServiceTable::KLtsyDispatchSimGetServiceTableApiId,KErrNone,data,0); + data.Close(); + + //CTSY defect would cause teh below expect, now if def'ed out see CMmPhoneTsy::CompleteCacheSimL + //error = 1; //CTSY sends down 1 + //simRefreshDoneExpLtsyData.SerialiseL(data); + //iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data); + //data.Close(); + + error = 0; + simRefreshDoneExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data); + data.Close(); + + + WaitForMockLTSYTerminated(); + + AssertMockLtsyStatusL(); + + //see phonebookfu for full refresh of Fdn and Adn phonebooks. + + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Power SIM On and Off +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::PowerSimOn() and RMmCustomAPI::PowerSimOff() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0007L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus reqStatus; + + /*******************************************************************/ + + //power sim on with complete returning KErrNone + TInt error = KErrNone; + + iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId); + iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId,error); + + customApi.PowerSimOn(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + AssertMockLtsyStatusL(); + + /*******************************************************************/ + + //power sim on with complete returning KErrGeneral + error = KErrGeneral; + + iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId); + iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOn::KLtsyDispatchSimPowerSimOnApiId,error); + + customApi.PowerSimOn(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + AssertMockLtsyStatusL(); + + /*******************************************************************/ + + //power sim off with complete returning KErrNone + error = KErrNone; + + iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId); + iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId,error); + + customApi.PowerSimOff(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + AssertMockLtsyStatusL(); + + /*******************************************************************/ + + //power sim off with complete returning KErrGeneral + error = KErrGeneral; + + iMockLTSY.ExpectL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId); + iMockLTSY.CompleteL(MLtsyDispatchSimPowerSimOff::KLtsyDispatchSimPowerSimOffApiId,error); + + customApi.PowerSimOff(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + AssertMockLtsyStatusL(); + + + + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for a send APDU request (async and sync) +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::SendAPDUReq() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0008L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + RBuf8 data; + CleanupClosePushL(data); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus reqStatus; + + _LIT8(KApduDataExp,"APDU DATA EXP "); + _LIT8(KApduDataComp,"APDU DATA COMP"); + TDesC8* commandData = const_cast(&KApduDataExp); + TDesC8* responseData = const_cast(&KApduDataComp); + + + /*****************************************************************************/ + //test SendAPDUReq async method in KErrNone case + + TInt error = KErrNone; + + TUint8 serviceTypeExp = 101; + TUint8 cardReaderNumberExp = 102; + TUint8 applicationTypeExp = 103; + TMockLtsyData4 sendApduReqExpData(serviceTypeExp,cardReaderNumberExp,applicationTypeExp,commandData); + sendApduReqExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSendApduRequest::KLtsyDispatchSimSendApduRequestApiId,data); + data.Close(); + + TUint8 serviceTypeComp = 201; + TUint8 cardReaderNumberComp = 202; + TUint8 applicationTypeComp = 203; + TMockLtsyData4 sendApduReqCompData(serviceTypeComp,cardReaderNumberComp,applicationTypeComp,responseData); + sendApduReqCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimSendApduRequest::KLtsyDispatchSimSendApduRequestApiId,error,data); + data.Close(); + + TBuf8<3> info; + info.Append(serviceTypeExp); + info.Append(cardReaderNumberExp); + info.Append(applicationTypeExp); + + RBuf8 dataBuf; + CleanupClosePushL(dataBuf); + dataBuf.CreateL(KApduDataExp); + + RMmCustomAPI::TApdu apdu(info,dataBuf); + customApi.SendAPDUReq(reqStatus,apdu); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + ASSERT_EQUALS(info[0],serviceTypeComp); + ASSERT_EQUALS(info[1],cardReaderNumberComp); + ASSERT_EQUALS(info[2],applicationTypeComp); + ASSERT_TRUE(dataBuf == KApduDataComp); + + AssertMockLtsyStatusL(); + + + /*****************************************************************************/ + //test SendAPDUReq async method in KErrGeneral case + + error = KErrGeneral; + + sendApduReqExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSendApduRequest::KLtsyDispatchSimSendApduRequestApiId,data); + data.Close(); + + sendApduReqCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimSendApduRequest::KLtsyDispatchSimSendApduRequestApiId,error,data); + data.Close(); + + info.Zero(); + info.Append(serviceTypeExp); + info.Append(cardReaderNumberExp); + info.Append(applicationTypeExp); + + dataBuf = KApduDataExp; + + customApi.SendAPDUReq(reqStatus,apdu); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + ASSERT_EQUALS(info[0],serviceTypeExp); //no change + ASSERT_EQUALS(info[1],cardReaderNumberExp); //no change + ASSERT_EQUALS(info[2],applicationTypeExp); //no change + ASSERT_TRUE(dataBuf == KApduDataExp); //no change + + AssertMockLtsyStatusL(); + + /*****************************************************************************/ + //test SendAPDUReq sync method in KErrNone case + + error = KErrNone; + + sendApduReqExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSendApduRequest::KLtsyDispatchSimSendApduRequestApiId,data); + data.Close(); + + sendApduReqCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimSendApduRequest::KLtsyDispatchSimSendApduRequestApiId,error,data); + data.Close(); + + info.Zero(); + info.Append(serviceTypeExp); + info.Append(cardReaderNumberExp); + info.Append(applicationTypeExp); + + dataBuf.Copy(KApduDataExp); + + TInt ret = customApi.SendAPDUReq(apdu); + ASSERT_EQUALS(ret,error); + ASSERT_EQUALS(info[0],serviceTypeComp); + ASSERT_EQUALS(info[1],cardReaderNumberComp); + ASSERT_EQUALS(info[2],applicationTypeComp); + ASSERT_TRUE(dataBuf == KApduDataComp); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(&dataBuf); + + /*****************************************************************************/ + //test SendAPDUReq V2 async method in KErrNone case + + error = KErrNone; + + const TUint8 KCardReaderId = 1; + RMmCustomAPI::TApduParameters apduParameters; + apduParameters.iCardReaderId = KCardReaderId; + apduParameters.iCmdData = KApduDataExp; + apduParameters.iRspData.Zero(); + + TMockLtsyData2 sendApduV2ReqExpData(apduParameters.iCardReaderId,commandData); + sendApduV2ReqExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSendApduRequestV2::KLtsyDispatchSimSendApduRequestV2ApiId,data); + data.Close(); + + + TMockLtsyData1 sendApduV2ReqCompData(responseData); + sendApduV2ReqCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimSendApduRequestV2::KLtsyDispatchSimSendApduRequestV2ApiId,error,data); + data.Close(); + + customApi.SendAPDUReq(reqStatus, apduParameters); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + ASSERT_EQUALS(apduParameters.iCardReaderId,KCardReaderId); //not changed + ASSERT_TRUE(apduParameters.iCmdData == KApduDataExp); //not changed + ASSERT_TRUE(apduParameters.iRspData == KApduDataComp); + + AssertMockLtsyStatusL(); + + /*****************************************************************************/ + //test SendAPDUReq V2 async method in KErrGeneral case + error = KErrGeneral; + + apduParameters.iCardReaderId = KCardReaderId; + apduParameters.iCmdData = KApduDataExp; + apduParameters.iRspData.Zero(); + + sendApduV2ReqExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSendApduRequestV2::KLtsyDispatchSimSendApduRequestV2ApiId,data); + data.Close(); + + sendApduV2ReqCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimSendApduRequestV2::KLtsyDispatchSimSendApduRequestV2ApiId,error,data); + data.Close(); + + customApi.SendAPDUReq(reqStatus, apduParameters); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + ASSERT_EQUALS(apduParameters.iCardReaderId,KCardReaderId); //not changed + ASSERT_TRUE(apduParameters.iCmdData == KApduDataExp); //not changed + ASSERT_TRUE(apduParameters.iRspData == KNullDesC8); //not changed + + AssertMockLtsyStatusL(); + + + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for SIM warm reset +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::SimWarmReset() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0009L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus reqStatus; + + TInt error = KErrNone; + + iMockLTSY.ExpectL(MLtsyDispatchSimSimWarmReset::KLtsyDispatchSimSimWarmResetApiId); + iMockLTSY.CompleteL(MLtsyDispatchSimSimWarmReset::KLtsyDispatchSimSimWarmResetApiId,error); + + customApi.SimWarmReset(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + AssertMockLtsyStatusL(); + + + error = KErrGeneral; + + iMockLTSY.ExpectL(MLtsyDispatchSimSimWarmReset::KLtsyDispatchSimSimWarmResetApiId); + iMockLTSY.CompleteL(MLtsyDispatchSimSimWarmReset::KLtsyDispatchSimSimWarmResetApiId,error); + + customApi.SimWarmReset(reqStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Notify Sim Card Status indicator +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::NotifySimCardStatus() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0010L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus reqStatus; + + TInt error = KErrNone; + + RMmCustomAPI::TSIMCardStatus cardStatus; + customApi.NotifySimCardStatus(reqStatus, cardStatus); + + RMmCustomAPI::TSIMCardStatus expectedStatus = RMmCustomAPI::SimCardInserted; + RBuf8 data; + TMockLtsyData1 completeData(expectedStatus); + completeData.SerialiseL(data); + iMockLTSY.CompleteL(KLtsyDispatchSimNotifySimCardStatusApiId,error,data); + data.Close(); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + ASSERT_EQUALS(cardStatus, expectedStatus); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Set SIM Message Status Read +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::SetSimMessageStatusRead() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0011L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + + TInt error = KErrNone; + + TTime expectedTime; + expectedTime.HomeTime(); + + TInt timeZoneDiff = 8; //2 hours ahead of GMT + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + RBuf8 data; + TMockLtsyData2 completeData(expectedTime, timeZoneDiff); + completeData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimSetSimMessageStatusRead::KLtsyDispatchSimSetSimMessageStatusReadApiId,data,error); + data.Close(); + iMockLTSY.CompleteL(MLtsyDispatchSimSetSimMessageStatusRead::KLtsyDispatchSimSetSimMessageStatusReadApiId,error); + + customApi.SetSimMessageStatusRead(expectedTime, timeZoneDiff); + + + User::WaitForRequest(reqStatus); + ASSERT_TRUE(reqStatus.Int() == KErrNone); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0012 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Read Sim File +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::ReadSimFile() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0012L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + RBuf8 data; + CleanupClosePushL(data); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus reqStatus; + + TInt error = KErrNone; + + //example Ef(Imsi) path + RMmCustomAPI::TSimFilePath path; + path.Append(0x3F); + path.Append(0x00); + path.Append(0x7F); + path.Append(0x00); + path.Append(0x6F); + path.Append(0x07); + path.Append(0x00); + path.Append(0x00); + + const TUint16 offset = 0; + const TUint16 size = 15; + + RMmCustomAPI::TSimFileInfo simFileInfo; + simFileInfo.iPath = path; + simFileInfo.iOffSet = offset; + simFileInfo.iSize = size; + RMmCustomAPI::TSimFileInfoPckg simFileInfoPckg(simFileInfo); + + TDesC8* pathPtr = &simFileInfo.iPath; + TMockLtsyData3 readSimExpData(pathPtr,simFileInfo.iOffSet,simFileInfo.iSize); + readSimExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimReadSimFile::KLtsyDispatchSimReadSimFileApiId,data); + data.Close(); + + _LIT8(KResponseBytes,"RESPONSE BYTES"); + TDesC8* responseBytesPtr = const_cast(&KResponseBytes); + TMockLtsyData1 readSimCompData(responseBytesPtr); + readSimCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimReadSimFile::KLtsyDispatchSimReadSimFileApiId,error,data); + data.Close(); + + TBuf8<20> responseBytes; + customApi.ReadSimFile(reqStatus,simFileInfoPckg,responseBytes); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + ASSERT_TRUE(responseBytes == KResponseBytes); + AssertMockLtsyStatusL(); + + /*****************************************************************************/ + + error = KErrGeneral; + readSimExpData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSimReadSimFile::KLtsyDispatchSimReadSimFileApiId,data); + data.Close(); + + readSimCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimReadSimFile::KLtsyDispatchSimReadSimFileApiId,error,data); + data.Close(); + + responseBytes.Zero(); + + customApi.ReadSimFile(reqStatus,simFileInfoPckg,responseBytes); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),error); + ASSERT_TRUE(responseBytes == KNullDesC8); + AssertMockLtsyStatusL(); + + + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0013 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Activate SimLock +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::ActivateSimLock() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0013L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + _LIT(KPassword, "12345"); + + RMmCustomAPI::TSimLockPassword simLockPassword; + RMmCustomAPI::TLockNumber lockNumber; + + lockNumber = RMmCustomAPI::EOperator; + simLockPassword.Copy(KPassword); + + TDesC* expectedSimLockPassword = const_cast (&KPassword); + RMmCustomAPI::TLockNumber expectedlockNumber = lockNumber; + TMockLtsyData2 activateSimLockData(expectedSimLockPassword, expectedlockNumber); + data.Close(); + activateSimLockData.SerialiseL(data); + + // asynchronous request + + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, KErrNone); + + customApi.ActivateSimLock(reqStatus, simLockPassword, lockNumber); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + // synchronous request + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, KErrNone); + + TInt ret = customApi.ActivateSimLock(simLockPassword, lockNumber); + ASSERT_EQUALS(KErrNone, ret); + + // failure case for asynchronous request + + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, KErrGeneral); + + customApi.ActivateSimLock(reqStatus, simLockPassword, lockNumber); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + + // failure case for synchronous request + + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockActivate::KLtsyDispatchSimSimLockActivateApiId, KErrGeneral); + + ret = customApi.ActivateSimLock(simLockPassword, lockNumber); + ASSERT_EQUALS(KErrGeneral, ret); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(3, this); //data, customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0014 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for DeActivate SimLock +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::DeActivateSimLock() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0014L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + _LIT(KPassword, "12345"); + + RMmCustomAPI::TSimLockPassword simLockPassword; + RMmCustomAPI::TLockNumber lockNumber; + + lockNumber = RMmCustomAPI::EOperator; + simLockPassword.Copy(KPassword); + + TDesC* expectedSimLockPassword = const_cast (&KPassword); + RMmCustomAPI::TLockNumber expectedlockNumber = lockNumber; + TMockLtsyData2 activateSimLockData(expectedSimLockPassword, expectedlockNumber); + data.Close(); + activateSimLockData.SerialiseL(data); + + // asynchronous request + + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, KErrNone); + + customApi.DeActivateSimLock(reqStatus, simLockPassword, lockNumber); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + // synchronous request + + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, KErrNone); + + TInt ret = customApi.DeActivateSimLock(simLockPassword, lockNumber); + ASSERT_EQUALS(KErrNone, ret); + + // failure case for asynchronous request + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, KErrGeneral); + + customApi.DeActivateSimLock(reqStatus, simLockPassword, lockNumber); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + + // failure case for synchronous request + + iMockLTSY.ExpectL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, data); + iMockLTSY.CompleteL(MLtsyDispatchSimSimLockDeActivate::KLtsyDispatchSimSimLockDeActivateApiId, KErrGeneral); + + ret = customApi.DeActivateSimLock(simLockPassword, lockNumber); + ASSERT_EQUALS(KErrGeneral, ret); + + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(3, this); //data, customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0015 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Get Answer to Reset +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::GetATR() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0015L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RBuf8 dataExpect; + CleanupClosePushL(dataExpect); + + RBuf8 dataComplete; + CleanupClosePushL(dataComplete); + + TRequestStatus reqStatus; + + _LIT8(KAnswerToResetSend, "ExampleAnswerToResetSend"); + _LIT8(KAnswerToResetReceive, "ExampleAnswerToResetReturn"); + TBuf8<100> answerToReset(KAnswerToResetSend); + + TDesC8* expectedAnswerToReset = const_cast (&KAnswerToResetSend); + TMockLtsyData1 getATRData(expectedAnswerToReset); + dataExpect.Close(); + getATRData.SerialiseL(dataExpect); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetAnswerToReset::KLtsyDispatchSimGetAnswerToResetApiId, dataExpect); + + TDesC8* returnAnswerToReset = const_cast (&KAnswerToResetReceive); + TMockLtsyData1 getATRDataReturn(returnAnswerToReset); + dataComplete.Close(); + getATRDataReturn.SerialiseL(dataComplete); + iMockLTSY.CompleteL(MLtsyDispatchSimGetAnswerToReset::KLtsyDispatchSimGetAnswerToResetApiId, KErrNone, dataComplete); + + customApi.GetATR(reqStatus, answerToReset); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + ASSERT_EQUALS(0, answerToReset.Compare(KAnswerToResetReceive)); + + // failure case + + TBuf8<100> answerToReset2(KAnswerToResetSend); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetAnswerToReset::KLtsyDispatchSimGetAnswerToResetApiId, dataExpect); + iMockLTSY.CompleteL(MLtsyDispatchSimGetAnswerToReset::KLtsyDispatchSimGetAnswerToResetApiId, KErrGeneral, dataComplete); + + customApi.GetATR(reqStatus, answerToReset2); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); // dataComplete, dataExpect, customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0016 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Get Sim Card Reader Status +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::GetSimCardReaderStatus() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0016L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RBuf8 dataComplete; + CleanupClosePushL(dataComplete); + + TRequestStatus reqStatus; + + RMmCustomAPI::TSimCardReaderStatus simCardReaderStatus; + + iMockLTSY.ExpectL(MLtsyDispatchSimGetSimCardReaderStatus::KLtsyDispatchSimGetSimCardReaderStatusApiId); + + TUint8 responseStatus = 10; + TMockLtsyData1 getSimReaderStatusDataReturn(responseStatus); + dataComplete.Close(); + getSimReaderStatusDataReturn.SerialiseL(dataComplete); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSimCardReaderStatus::KLtsyDispatchSimGetSimCardReaderStatusApiId, KErrNone, dataComplete); + + customApi.GetSimCardReaderStatus(reqStatus, simCardReaderStatus); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + ASSERT_EQUALS(responseStatus, simCardReaderStatus.GetStatus()); + + // failure case + + iMockLTSY.ExpectL(MLtsyDispatchSimGetSimCardReaderStatus::KLtsyDispatchSimGetSimCardReaderStatusApiId); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSimCardReaderStatus::KLtsyDispatchSimGetSimCardReaderStatusApiId, KErrGeneral, dataComplete); + + RMmCustomAPI::TSimCardReaderStatus simCardReaderStatus2; + simCardReaderStatus2.SetStatus(0); + + customApi.GetSimCardReaderStatus(reqStatus, simCardReaderStatus2); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(3, this); // dataComplete, customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SIM-UN0017 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSYDispatch for Get Wlan Sim Authentication Data +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::GetWlanSimAuthenticationData() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySimFU::TestUnit0017L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RBuf8 dataExpect; + CleanupClosePushL(dataExpect); + RBuf8 dataComplete; + CleanupClosePushL(dataComplete); + + TRequestStatus reqStatus; + TUint32 randomValue; + + _LIT8(KCK,"CipheringKey"); + _LIT8(KIK,"IntegrityKey"); + _LIT8(KRES,"Response"); + _LIT8(KAUTN,"AUTN Value"); + _LIT8(KAUTS,"AUTS Value"); + + TDesC8* responseCipheringKey = const_cast(&KCK); + TDesC8* responseIntegrityKey = const_cast(&KIK); + TDesC8* responseResponse = const_cast(&KRES); + TDesC8* responseAUTN = const_cast(&KAUTN); + TDesC8* responseAUTS = const_cast(&KAUTS); + + TInt rfStateInfo ( 0 ); // assume that rfStateInfo has not been set + + // generate a random parameter + TBuf8<16> randomParameter; + for (TInt i = 0; i< 16; i++) + { + randomValue = Math::Random(); + randomParameter.Append(randomValue); + } + TDesC8* responseRandomParam = &randomParameter; + + // EapSim method + TMockLtsyData2 getSimAuthenticationEapSimData(responseRandomParam, rfStateInfo); + dataExpect.Close(); + getSimAuthenticationEapSimData.SerialiseL(dataExpect); + iMockLTSY.ExpectL(MLtsyDispatchSimGetSimAuthenticationEapSimData::KLtsyDispatchSimGetSimAuthenticationEapSimDataApiId, dataExpect); + + TMockLtsyData2 getSimAuthenticationEapSimDataReturn(responseResponse, responseCipheringKey); + dataComplete.Close(); + getSimAuthenticationEapSimDataReturn.SerialiseL(dataComplete); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSimAuthenticationEapSimData::KLtsyDispatchSimGetSimAuthenticationEapSimDataApiId, KErrNone, dataComplete); + + + RMmCustomAPI::TSimAuthenticationEapSim eapSim; + eapSim.iRandomParameters.Copy(randomParameter); + RMmCustomAPI::TSimDataPckg simDataPckg(eapSim); + customApi.GetWlanSimAuthenticationData(reqStatus, simDataPckg); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + ASSERT_EQUALS(0, eapSim.iSRES.Compare(KRES)); + ASSERT_EQUALS(0, eapSim.iKC.Compare(KCK)); + + // failure case of EapSim method + + randomParameter.Zero(); + for (TInt j = 0; j< 16; j++) + { + randomValue = Math::Random(); + randomParameter.Append(randomValue); + } + responseRandomParam = &randomParameter; + + TMockLtsyData2 getSimAuthenticationEapSimData2(responseRandomParam, rfStateInfo); + dataExpect.Close(); + getSimAuthenticationEapSimData2.SerialiseL(dataExpect); + iMockLTSY.ExpectL(MLtsyDispatchSimGetSimAuthenticationEapSimData::KLtsyDispatchSimGetSimAuthenticationEapSimDataApiId, dataExpect); + + iMockLTSY.CompleteL(MLtsyDispatchSimGetSimAuthenticationEapSimData::KLtsyDispatchSimGetSimAuthenticationEapSimDataApiId, KErrGeneral, dataComplete); + + + RMmCustomAPI::TSimAuthenticationEapSim eapSim2; + eapSim2.iRandomParameters.Copy(randomParameter); + RMmCustomAPI::TSimDataPckg simDataPckg2(eapSim2); + customApi.GetWlanSimAuthenticationData(reqStatus, simDataPckg2); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + + // EapAka method + + // generate a random parameter + TBuf8<16> randomParameter2; + for (TInt k = 0; k< 16; k++) + { + randomValue = Math::Random(); + randomParameter2.Append(randomValue); + } + TDesC8* responseRandomParam2 = &randomParameter2; + + TMockLtsyData3 getSimAuthenticationEapAkaData(responseRandomParam2, responseAUTN, rfStateInfo); + dataExpect.Close(); + getSimAuthenticationEapAkaData.SerialiseL(dataExpect); + iMockLTSY.ExpectL(MLtsyDispatchSimGetSimAuthenticationEapAkaData::KLtsyDispatchSimGetSimAuthenticationEapAkaDataApiId, dataExpect); + + TMockLtsyData4 getSimAuthenticationEapAkaDataReturn(responseResponse, responseCipheringKey, responseIntegrityKey, responseAUTS); + dataComplete.Close(); + getSimAuthenticationEapAkaDataReturn.SerialiseL(dataComplete); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSimAuthenticationEapAkaData::KLtsyDispatchSimGetSimAuthenticationEapAkaDataApiId, KErrNone, dataComplete); + + RMmCustomAPI::TSimAuthenticationEapAka eapAka; + eapAka.iRandomParameters.Copy(randomParameter2); + eapAka.iAUTN.Copy(KAUTN); + RMmCustomAPI::TAkaDataPckg akaDataPckg(eapAka); + + customApi.GetWlanSimAuthenticationData(reqStatus, akaDataPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + ASSERT_EQUALS(0, eapAka.iRES.Compare(KRES)); + ASSERT_EQUALS(0, eapAka.iCK.Compare(KCK)); + ASSERT_EQUALS(0, eapAka.iIK.Compare(KIK)); + + // failure case of EapAka method to check AUTS value + + // generate a random parameter + TBuf8<16> randomParameter3; + for (TInt l = 0; l< 16; l++) + { + randomValue = Math::Random(); + randomParameter3.Append(randomValue); + } + TDesC8* responseRandomParam3 = &randomParameter3; + + TMockLtsyData3 getSimAuthenticationEapAkaData2(responseRandomParam3, responseAUTN, rfStateInfo); + dataExpect.Close(); + getSimAuthenticationEapAkaData2.SerialiseL(dataExpect); + iMockLTSY.ExpectL(MLtsyDispatchSimGetSimAuthenticationEapAkaData::KLtsyDispatchSimGetSimAuthenticationEapAkaDataApiId, dataExpect); + + iMockLTSY.CompleteL(MLtsyDispatchSimGetSimAuthenticationEapAkaData::KLtsyDispatchSimGetSimAuthenticationEapAkaDataApiId, KErrGeneral, dataComplete); + + RMmCustomAPI::TSimAuthenticationEapAka eapAka2; + eapAka2.iRandomParameters.Copy(randomParameter3); + eapAka2.iAUTN.Copy(KAUTN); + RMmCustomAPI::TAkaDataPckg akaDataPckg2(eapAka2); + + customApi.GetWlanSimAuthenticationData(reqStatus, akaDataPckg2); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrGeneral, reqStatus.Int()); + ASSERT_EQUALS(0, eapAka2.iAUTS.Compare(KAUTS)); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(4, this); //dataComplete, dataExpect, customApi, this + }