/*
* Copyright (c) 2008-2010 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 CustomIPC in the Common TSY.
*/
#include "cctsycustomipcfu.h"
#include <ctsy/mmtsy_names.h>
#include <etel.h>
#include <etelmm.h>
#include "tmockltsydata.h"
#include <ctsy/serviceapi/gsmerror.h>
#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
#include "CMmCustomSecurityTsy.h"
// constants used by ReadViagHomeZoneCache/WriteViagHomeZoneCache tests
const TInt KViagHomeZoneCacheIdMin = 1;
const TInt KViagHomeZoneCacheIdMax = KPhEngMaxViagHomeZones;
const TInt KViagHomeZoneCacheRecordIdMin = 0;
const TInt KViagHomeZoneCacheRecordIdMax = KPhEngMaxCacheId - 1;
const TInt KOneSecond=1000000; // Used in a time out function, 1 second (in microSeconds)
CTestSuite* CCTsyCustomIPCFU::CreateSuiteL(const TDesC& aName)
{
SUB_SUITE;
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetDriveMode0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestActivateSimLock0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeActivateSimLock0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyDtmfEvent0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyDtmfEvent0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyDtmfEvent0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetDiagnosticInfo0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlsBlocked0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAlsBlocked0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckAlsPpSupport0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetRemoteAlertingToneStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCallOrigin0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestTerminateCall0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyAlsBlockedChanged0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyAlsBlockedChanged0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyAlsBlockedChanged0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCipheringInfo0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCipheringInfoChange0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCipheringInfoChange0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCipheringInfoChange0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNSPSStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNSPSStatus0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNSPSStatus0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNetWakeup0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneParams0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0001bL);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0001cL);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadViagHomeZoneCache0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneCache0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestClearCallBlackList0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsAdditionalInfoNotification0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsAdditionalInfoNotification0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsAdditionalInfoNotification0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsRequestCompleteNotification0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsRequestCompleteNotification0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSsRequestCompleteNotification0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestIsBlocked0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestIsBlocked0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckSecurityCode0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetActivePin0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetAirTimeDuration0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNetworkProviderName0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckEmergencyNumber0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0001bL);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyPndCacheReady0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetPndCacheStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetPndCacheStatus0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetOperatorName0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetProgrammableOperatorLogo0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyProgrammableOperatorLogoChange0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySsNetworkEvent0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySsNetworkEvent0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySsNetworkEvent0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCancelUssdSession0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSatRefreshCompleteNotification0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSatRefreshCompleteNotification0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSatRefreshCompleteNotification0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestCheckTwoDigitDialSupport0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestResetNetServer0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReleaseFile0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestRestartFile0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestStartSimCbTopicBrowsing0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestStartSimCbTopicBrowsing0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestStartSimCbTopicBrowsing0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetNextSimCbTopic0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDeleteSimCbTopic0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNetworkConnectionFailure0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNetworkConnectionFailure0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyNetworkConnectionFailure0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSendAPDUReq0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestDisablePhoneLock0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyEGprsInfoChange0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetEGprsInfo0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetEGprsInfo0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadSimFile0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetLifeTime0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGet3GPBInfo0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkModes0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkMode0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCurrentSystemNetworkModes0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOn0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestPowerSimOff0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSimWarmReset0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetATR0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSimCardReaderStatus0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySimCardStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySimCardStatus0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifySimCardStatus0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0001L); //!!!
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetWlanSimAuthenticationData0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSimMessageStatusRead0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteViagHomeZoneUHZIUESettings0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetAlwaysOn0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyRauEvent0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyRauEvent0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyRauEvent0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestReadHSxPAStatus0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestWriteHSxPAStatus0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyHSxPAStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyHSxPAStatus0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyHSxPAStatus0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetIccCallForwardingIndicatorStatus0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyIccCallForwardingStatusChange0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetCellInfo0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestNotifyCellInfoChange0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetSystemNetworkBand0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestSetSystemNetworkBand0005L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0001L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0002L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0003L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0004L);
ADD_TEST_STEP_ISO_CPP(CCTsyCustomIPCFU, TestGetUSIMServiceSupport0005L);
END_SUITE;
}
//////////////////////////////////////////////////////////////////
// Actual test cases
/////////////////////////////////////////////////////////////////
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSDM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetDriveMode
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetDriveMode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetDriveMode0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
// data for ExpectL
TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData, KErrNotSupported);
customAPI.SetDriveMode(requestStatus, modeStatus);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);
iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrGeneral);
customAPI.SetDriveMode(requestStatus, modeStatus);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SetDriveMode when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);
iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone);
customAPI.SetDriveMode(requestStatus, modeStatus);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SetDriveMode
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSDM-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SetDriveMode
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SetDriveMode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetDriveMode0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SetDriveMode
//-------------------------------------------------------------------------
// data for ExpectL
TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);
customAPI.SetDriveMode(requestStatus, modeStatus);
iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone, 20);
customAPI.CancelAsyncRequest(ECustomSetDriveModeIPC);
User::WaitForRequest(requestStatus);
// TSY has started a request and it is not possible to then
// cancel it. The best thing for the TSY to do in
// this case is to proceed as though the Cancel never happened.
// The server's call to the TSY cancel function will return
// synchronously. The TSY then continues to wait for the methods
// acknowledgement and when it receives it, the TSY will complete
// the original request.
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSDM-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SetDriveMode
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SetDriveMode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetDriveMode0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 expectData2;
CleanupClosePushL(expectData2);
TRequestStatus requestStatus;
RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode);
TRequestStatus requestStatus2;
RMmCustomAPI::TSetDriveMode modeStatus2(RMmCustomAPI::EDeactivateDriveMode);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::SetDriveMode
//-------------------------------------------------------------------------
// data for the first ExpectL
TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);
ltsyData.SerialiseL(expectData);
// data for the second ExpectL
TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData2(modeStatus2);
ltsyData2.SerialiseL(expectData2);
// first SetDriveMode
iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);
iMockLTSY.CompleteL(ECustomSetDriveModeIPC, KErrNone, 20);
customAPI.SetDriveMode(requestStatus, modeStatus);
customAPI2.SetDriveMode(requestStatus2, modeStatus2);
// wait for the first answer
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// wait for the second answer
User::WaitForRequest(requestStatus2);
// Documentation says that KErrServerBusy should be in case of multiple requests
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(8, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSDM-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetDriveMode with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetDriveMode and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetDriveMode0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSetDriveMode modeStatus(RMmCustomAPI::EActivateDriveMode);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::SetDriveMode
//-------------------------------------------------------------------------
// data for ExpectL
TMockLtsyData1< RMmCustomAPI::TSetDriveMode > ltsyData(modeStatus);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSetDriveModeIPC, expectData);
customAPI.SetDriveMode(requestStatus, modeStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCASL-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ActivateSimLock
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ActivateSimLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestActivateSimLock0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator);
// data for ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber >
ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData, KErrNotSupported);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
// use othere number for coverage increasing
lockNumber = RMmCustomAPI::EGid1;
// data for ExpectL
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrGeneral);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::ActivateSimLock when result is not cached.
//-------------------------------------------------------------------------
// use othere number for coverage increasing
lockNumber = RMmCustomAPI::EGid2;
// data for ExpectL
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::ActivateSimLock
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// just to increase coverage
//-------------------------------------------------------------------------
// use othere number for coverage increasing
lockNumber = RMmCustomAPI::EImsi;
// data for ExpectL
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCASL-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ActivateSimLock
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::ActivateSimLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestActivateSimLock0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
// to wait CompleteL
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::ActivateSimLock
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EImsi);
// data for ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber >
ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
// cancel this request
customAPI.CancelAsyncRequest(ECustomSimLockActivateIPC);
// try to complete canceled request
iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);
// wait for request
User::WaitForRequest(requestStatus);
// this request can't be canceled
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// wait for CompleteL
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCASL-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ActivateSimLock with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ActivateSimLock with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestActivateSimLock0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test A: Test passing wrong parameters to
// RMmCustomAPI::ActivateSimLock
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber((RMmCustomAPI::TLockNumber) 0);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCASL-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ActivateSimLock
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::ActivateSimLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestActivateSimLock0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::ActivateSimLock
//-------------------------------------------------------------------------
// data for the first request
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator_Gid1);
// data for the second request
RMmCustomAPI::TSimLockPassword password2(_L("changemechangemechangemechang2"));
RMmCustomAPI::TLockNumber lockNumber2(RMmCustomAPI::EOperator_Gid2);
// data for the first ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
// send first request
iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockActivateIPC, KErrNone);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
// send second request
customAPI2.ActivateSimLock(requestStatus2, password2, lockNumber2);
// wait for the first answer
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// wait for the second answer
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
// Done !
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCASL-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ActivateSimLock with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ActivateSimLock and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestActivateSimLock0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::ActivateSimLock
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator_Gid2);
// data for ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber >
ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockActivateIPC, expectData);
customAPI.ActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
// Done !
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDASL-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DeActivateSimLock
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DeActivateSimLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeActivateSimLock0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator);
// data for ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber >
ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData, KErrNotSupported);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
// use othere number for coverage increasing
lockNumber = RMmCustomAPI::EGid1;
// data for ExpectL
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrGeneral);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::DeActivateSimLock when result is not cached.
//-------------------------------------------------------------------------
// use othere number for coverage increasing
lockNumber = RMmCustomAPI::EGid2;
// data for ExpectL
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::DeActivateSimLock
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// just to increase coverage
//-------------------------------------------------------------------------
// use othere number for coverage increasing
lockNumber = RMmCustomAPI::EGlobalUnlock;
// data for ExpectL
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// just to increase coverage
//-------------------------------------------------------------------------
// use othere number for coverage increasing
lockNumber = RMmCustomAPI::EImsi;
// data for ExpectL
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDASL-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::DeActivateSimLock
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::DeActivateSimLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeActivateSimLock0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
// to wait CompleteL
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::DeActivateSimLock
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EImsi);
// data for ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber >
ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
// cancel this request
customAPI.CancelAsyncRequest(ECustomSimLockDeActivateIPC);
// try to complete canceled request
iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);
// wait for request
User::WaitForRequest(requestStatus);
// this request can't be canceled
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// wait for CompleteL
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDASL-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DeActivateSimLock with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DeActivateSimLock with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeActivateSimLock0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test A: Test passing wrong version of parameters to
// RMmCustomAPI::DeActivateSimLock
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber((RMmCustomAPI::TLockNumber) 0);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDASL-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::DeActivateSimLock
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::DeActivateSimLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeActivateSimLock0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::DeActivateSimLock
//-------------------------------------------------------------------------
// data for the first request
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator_Gid1);
// data for the second request
RMmCustomAPI::TSimLockPassword password2(_L("changemechangemechangemechang2"));
RMmCustomAPI::TLockNumber lockNumber2(RMmCustomAPI::EOperator_Gid2);
// data for the first ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber > ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
// send first request
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);
iMockLTSY.CompleteL(ECustomSimLockDeActivateIPC, KErrNone);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
// send second request
customAPI2.DeActivateSimLock(requestStatus2, password2, lockNumber2);
// wait for the first answer
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// wait for the second answer
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
// Done !
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDASL-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DeActivateSimLock with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DeActivateSimLock and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeActivateSimLock0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::DeActivateSimLock
//-------------------------------------------------------------------------
RMmCustomAPI::TSimLockPassword password(_L("changemechangemechangemechange"));
RMmCustomAPI::TLockNumber lockNumber(RMmCustomAPI::EOperator_Gid2);
// data for ExpectL
TMockLtsyData2< RMmCustomAPI::TSimLockPassword, RMmCustomAPI::TLockNumber >
ltsyData(password, lockNumber);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSimLockDeActivateIPC, expectData);
customAPI.DeActivateSimLock(requestStatus, password, lockNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
// Done !
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNDE-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyDtmfEvent
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyDtmfEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyDtmfEvent0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for CompleteL
RMmCustomAPI::TDtmfInfo completeInfo;
completeInfo.iType = RMmCustomAPI::EDtmfSequence;
completeInfo.iEvent = RMmCustomAPI::EDtmfStop;
completeInfo.iTone = 0x10;
TMockLtsyData1 <RMmCustomAPI::TDtmfInfo> ltsyData(completeInfo);
ltsyData.SerialiseL(completeData);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyDtmfEvent
// from LTSY.
// Test here cause this is a self-reposting request.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyDtmfEventIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// data for NotifyDtmfEvent itself
TRequestStatus requestStatus;
RMmCustomAPI::TDtmfInfo info;
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
customAPI.NotifyDtmfEvent(requestStatus, info);
iMockLTSY.CompleteL(ECustomNotifyDtmfEventIPC, KErrGeneral, completeData);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyDtmfEvent when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyDtmfEvent(requestStatus, info);
iMockLTSY.CompleteL(ECustomNotifyDtmfEventIPC, KErrNone, completeData);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
ASSERT_EQUALS(completeInfo.iType, info.iType);
ASSERT_EQUALS(completeInfo.iEvent, info.iEvent);
ASSERT_EQUALS(completeInfo.iTone, info.iTone);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNDE-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyDtmfEvent
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyDtmfEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyDtmfEvent0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for CompleteL
RMmCustomAPI::TDtmfInfo completeInfo;
completeInfo.iType = RMmCustomAPI::EDtmfSequence;
completeInfo.iEvent = RMmCustomAPI::EDtmfStop;
completeInfo.iTone = 0x10;
TMockLtsyData1 <RMmCustomAPI::TDtmfInfo> ltsyData(completeInfo);
ltsyData.SerialiseL(completeData);
// data for NotifyDtmfEvent itself
TRequestStatus requestStatus;
RMmCustomAPI::TDtmfInfo info;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyDtmfEvent
//-------------------------------------------------------------------------
customAPI.NotifyDtmfEvent(requestStatus, info);
// cancel request
customAPI.CancelAsyncRequest(ECustomNotifyDtmfEventIPC);
// try to complete request
iMockLTSY.CompleteL(ECustomNotifyDtmfEventIPC, KErrNone, completeData);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
// Wait for completion of iMockLTSY.NotifyTerminated
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNDE-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyDtmfEvent
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyDtmfEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyDtmfEvent0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2, KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI2;
CleanupClosePushL(customAPI2);
customAPI2.Open(phone2);
// data for CompleteL
RMmCustomAPI::TDtmfInfo completeInfo;
completeInfo.iType = RMmCustomAPI::EDtmfSequence;
completeInfo.iEvent = RMmCustomAPI::EDtmfStop;
completeInfo.iTone = 0x10;
TMockLtsyData1 <RMmCustomAPI::TDtmfInfo> ltsyData(completeInfo);
ltsyData.SerialiseL(completeData);
// data for the first NotifyDtmfEvent
TRequestStatus requestStatus;
RMmCustomAPI::TDtmfInfo info;
// data for the second NotifyDtmfEvent
TRequestStatus requestStatus2;
RMmCustomAPI::TDtmfInfo info2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyDtmfEvent
//-------------------------------------------------------------------------
// send first request
customAPI.NotifyDtmfEvent(requestStatus, info);
// send second request
customAPI2.NotifyDtmfEvent(requestStatus2, info2);
// Complete
iMockLTSY.CompleteL(ECustomNotifyDtmfEventIPC, KErrNone, completeData);
// wait for the first answer
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// wait for the second answer
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
AssertMockLtsyStatusL();
// check first request's data
ASSERT_EQUALS(completeInfo.iType, info.iType);
ASSERT_EQUALS(completeInfo.iEvent, info.iEvent);
ASSERT_EQUALS(completeInfo.iTone, info.iTone);
// check second request's data
ASSERT_EQUALS(completeInfo.iType, info2.iType);
ASSERT_EQUALS(completeInfo.iEvent, info2.iEvent);
ASSERT_EQUALS(completeInfo.iTone, info2.iTone);
// Done !
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGDO-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetDiagnosticInfo
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetDiagnosticInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetDiagnosticInfo0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// try to get info for non-existing call
//-------------------------------------------------------------------------
TName callName;
TInt status = customAPI.GetDiagnosticInfo(callName);
ASSERT_EQUALS(KErrNotFound, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with initial iDiagnosticOctet ( == NULL)
//-------------------------------------------------------------------------
// -----------Open Line and Call ---------------------
RLine line;
RCall call;
// Open new line
TInt errorCode = line.Open(iPhone, KMmTsyVoice1LineName);
ASSERT_EQUALS(KErrNone, errorCode);
CleanupClosePushL(line);
TName incomingCallName;
TInt callId = 1;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
// create new incoming call
errorCode = CreateIncomingCallL(line, callId, KMmTsyVoice1LineName, incomingCallName,
mobileService, mobileCallStatus);
ASSERT_EQUALS(KErrNone, errorCode);
CleanupClosePushL(call);
errorCode = call.OpenExistingCall(line, incomingCallName);
ASSERT_EQUALS(KErrNone, errorCode);
//-------------------------------------------------------------------------
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrNone, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredWithCUG
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TDiagnosticInfoValues diagnostic(KDiagnosticInfoBarredWithCUG);
TMockLtsyData2 <TInt, TDiagnosticInfoValues> ltsyData(callId, diagnostic);
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredWithCUG, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredNoCUG
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
diagnostic = KDiagnosticInfoBarredNoCUG;
completeData.Close();
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredNoCUG, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredUnknownCUG
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
diagnostic = KDiagnosticInfoBarredUnknownCUG;
completeData.Close();
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredUnknownCUG, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredIncompatibleCUG
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
diagnostic = KDiagnosticInfoBarredIncompatibleCUG;
completeData.Close();
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredIncompatibleCUG, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredFailureCUG
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
diagnostic = KDiagnosticInfoBarredFailureCUG;
completeData.Close();
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredFailureCUG, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredClirNotSubscribed
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
diagnostic = KDiagnosticInfoBarredClirNotSubscribed;
completeData.Close();
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredClirNotSubscribed, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredCCBSPossible
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
diagnostic = KDiagnosticInfoBarredCCBSPossible;
completeData.Close();
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredCCBSPossible, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = KDiagnosticInfoBarredCCBSNotPossible
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
diagnostic = KDiagnosticInfoBarredCCBSNotPossible;
completeData.Close();
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrDiagnosticInfoBarredCCBSNotPossible, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// try to get info for existing call, with iDiagnosticOctet = some arbitrary value
//-------------------------------------------------------------------------
// set iDiagnosticOctet ...
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TInt someDiagnostic = -11; // some arbitrary value
TMockLtsyData2 <TInt, TInt> ltsyData2(callId, someDiagnostic);
completeData.Close();
ltsyData2.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// ... and get info
status = customAPI.GetDiagnosticInfo(incomingCallName);
ASSERT_EQUALS(KErrNone, status);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetDiagnosticInfo
// from LTSY.
//-------------------------------------------------------------------------
//just set iDiagnosticOctet to non-existing callId
iMockLTSY.NotifyTerminated(mockLtsyStatus);
callId = 100;
completeData.Close();
ltsyData2.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetDiagnosticOctetsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAB-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetAlsBlocked
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetAlsBlocked
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlsBlocked0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for SetAlsBlocked itself
TRequestStatus reguestStatus;
RMmCustomAPI::TSetAlsBlock blockStatus(RMmCustomAPI::EActivateBlock);
// data for ExpectL
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData(blockStatus);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData, KErrNotSupported);
customAPI.SetAlsBlocked(reguestStatus, blockStatus);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNotSupported, reguestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrGeneral);
customAPI.SetAlsBlocked(reguestStatus, blockStatus);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrGeneral, reguestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SetAlsBlocked when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone);
customAPI.SetAlsBlocked(reguestStatus, blockStatus);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SetAlsBlocked
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAB-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SetAlsBlocked
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SetAlsBlocked
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlsBlocked0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for SetAlsBlocked itself
TRequestStatus reguestStatus;
RMmCustomAPI::TSetAlsBlock blockStatus(RMmCustomAPI::EActivateBlock);
// data for ExpectL
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData(blockStatus);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SetAlsBlocked
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
customAPI.SetAlsBlocked(reguestStatus, blockStatus);
// try to cancel request
customAPI.CancelAsyncRequest(ECustomSetAlsBlockedIPC);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone);
User::WaitForRequest(reguestStatus);
// TSY has started a request and it is not possible to then
// cancel it. The best thing for the TSY to do in
// this case is to proceed as though the Cancel never happened.
// The server's call to the TSY cancel function will return
// synchronously. The TSY then continues to wait for the methods
// acknowledgement and when it receives it, the TSY will complete
// the original request.
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAB-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SetAlsBlocked
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SetAlsBlocked
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlsBlocked0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 expectData2;
CleanupClosePushL(expectData2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
// data for the first SetAlsBlocked
TRequestStatus reguestStatus;
RMmCustomAPI::TSetAlsBlock blockStatus(RMmCustomAPI::EDeactivateBlock);
// data for the first ExpectL
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData(blockStatus);
ltsyData.SerialiseL(expectData);
// data for the second SetAlsBlocked
TRequestStatus reguestStatus2;
RMmCustomAPI::TSetAlsBlock blockStatus2(RMmCustomAPI::EActivateBlock);
// data for the second ExpectL
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData2(blockStatus2);
ltsyData2.SerialiseL(expectData2);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::SetAlsBlocked
//-------------------------------------------------------------------------
// first request
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone, 10);
customAPI.SetAlsBlocked(reguestStatus, blockStatus);
// there is no way to check KErrServerBusy return value because second
// request is put to a wating queue by ETel and it is resumed only after
// first request is completed
customAPI2.SetAlsBlocked(reguestStatus2, blockStatus2);
// wait for the first request
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
// wait for the second request
User::WaitForRequest(reguestStatus2);
// Documentation says that KErrServerBusy should be in case of multiple requests
ASSERT_EQUALS(KErrServerBusy, reguestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAB-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetAlsBlocked with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetAlsBlocked and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlsBlocked0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for SetAlsBlocked itself
TRequestStatus reguestStatus;
RMmCustomAPI::TSetAlsBlock blockStatus(RMmCustomAPI::EActivateBlock);
// data for ExpectL
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData(blockStatus);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::SetAlsBlocked
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
customAPI.SetAlsBlocked(reguestStatus, blockStatus);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrTimedOut, reguestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGAB-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetAlsBlocked
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetAlsBlocked
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetAlsBlocked0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for GetAlsBlocked itself
TRequestStatus reguestStatus;
RMmCustomAPI::TGetAlsBlockStatus blockStatus(RMmCustomAPI::EBlockStatusUnknown);
// data for CompleteL
RMmCustomAPI::TGetAlsBlockStatus completeBlockStatus(RMmCustomAPI::EBlockStatusActive);
TMockLtsyData1< RMmCustomAPI::TGetAlsBlockStatus > ltsyData(completeBlockStatus);
ltsyData.SerialiseL(completeData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetAlsBlockedIPC, KErrNotSupported);
customAPI.GetAlsBlocked(reguestStatus, blockStatus);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNotSupported, reguestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetAlsBlockedIPC);
iMockLTSY.CompleteL(ECustomGetAlsBlockedIPC, KErrGeneral, completeData);
customAPI.GetAlsBlocked(reguestStatus, blockStatus);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrGeneral, reguestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetAlsBlocked when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetAlsBlockedIPC);
iMockLTSY.CompleteL(ECustomGetAlsBlockedIPC, KErrNone, completeData);
customAPI.GetAlsBlocked(reguestStatus, blockStatus);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
ASSERT_EQUALS(completeBlockStatus, blockStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetAlsBlocked
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetAlsBlockedIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGAB-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetAlsBlocked
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetAlsBlocked
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetAlsBlocked0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for GetAlsBlocked itself
TRequestStatus reguestStatus;
RMmCustomAPI::TGetAlsBlockStatus blockStatus(RMmCustomAPI::EBlockStatusUnknown);
// data for CompleteL
RMmCustomAPI::TGetAlsBlockStatus completeBlockStatus(RMmCustomAPI::EBlockStatusActive);
TMockLtsyData1< RMmCustomAPI::TGetAlsBlockStatus > ltsyData(completeBlockStatus);
ltsyData.SerialiseL(completeData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetAlsBlocked
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetAlsBlockedIPC);
customAPI.GetAlsBlocked(reguestStatus, blockStatus);
// try to cancel request
customAPI.CancelAsyncRequest(ECustomGetAlsBlockedIPC);
// try to Complete request
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetAlsBlockedIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// wait for request completion
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrCancel, reguestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGAB-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetAlsBlocked
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetAlsBlocked
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetAlsBlocked0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI2;
CleanupClosePushL(customAPI2);
customAPI2.Open(phone2);
// data for the first GetAlsBlocked
TRequestStatus reguestStatus;
RMmCustomAPI::TGetAlsBlockStatus blockStatus(RMmCustomAPI::EBlockStatusUnknown);
// data for the first CompleteL
RMmCustomAPI::TGetAlsBlockStatus completeBlockStatus(RMmCustomAPI::EBlockStatusInactive);
TMockLtsyData1< RMmCustomAPI::TGetAlsBlockStatus > ltsyData(completeBlockStatus);
ltsyData.SerialiseL(completeData);
// data for the second GetAlsBlocked
TRequestStatus reguestStatus2;
RMmCustomAPI::TGetAlsBlockStatus blockStatus2(RMmCustomAPI::EBlockStatusUnknown);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetAlsBlocked
//-------------------------------------------------------------------------
// first request
iMockLTSY.ExpectL(ECustomGetAlsBlockedIPC);
iMockLTSY.CompleteL(ECustomGetAlsBlockedIPC, KErrNone, completeData, 10);
customAPI.GetAlsBlocked(reguestStatus, blockStatus);
// second request
customAPI2.GetAlsBlocked(reguestStatus2, blockStatus2);
// wait for the first answer
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
ASSERT_EQUALS(completeBlockStatus, blockStatus);
// wait for the second answer
User::WaitForRequest(reguestStatus2);
ASSERT_EQUALS(KErrServerBusy, reguestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGAB-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetAlsBlocked with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetAlsBlocked and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetAlsBlocked0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for GetAlsBlocked itself
TRequestStatus reguestStatus;
RMmCustomAPI::TGetAlsBlockStatus blockStatus(RMmCustomAPI::EBlockStatusUnknown);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::GetAlsBlocked
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetAlsBlockedIPC);
customAPI.GetAlsBlocked(reguestStatus, blockStatus);
// wait for request completion
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrTimedOut, reguestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCAPS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckAlsPpSupport
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckAlsPpSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckAlsPpSupport0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for CompleteL
RMmCustomAPI::TAlsSupport completeAlsSupport(RMmCustomAPI::EAlsSupportOff);
TMockLtsyData1< RMmCustomAPI::TAlsSupport > ltsyData(completeAlsSupport);
ltsyData.SerialiseL(completeData);
// data for CheckAlsPpSupport itself
TRequestStatus reguestStatus;
RMmCustomAPI::TAlsSupport alsSupport;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC, KErrNotSupported);
customAPI.CheckAlsPpSupport(reguestStatus, alsSupport);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNotSupported, reguestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.CompleteL(ECustomCheckAlsPpSupportIPC, KErrGeneral, completeData);
customAPI.CheckAlsPpSupport(reguestStatus, alsSupport);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrGeneral, reguestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::CheckAlsPpSupport when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.CompleteL(ECustomCheckAlsPpSupportIPC, KErrNone, completeData);
customAPI.CheckAlsPpSupport(reguestStatus, alsSupport);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
ASSERT_EQUALS(completeAlsSupport, alsSupport);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C1 just to increase coverage
//-------------------------------------------------------------------------
// new data for CompleteL
RMmCustomAPI::TAlsSupport completeAlsSupport2(RMmCustomAPI::EAlsSupportOn);
TMockLtsyData1< RMmCustomAPI::TAlsSupport > ltsyData2(completeAlsSupport2);
completeData.Close();
ltsyData2.SerialiseL(completeData);
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.CompleteL(ECustomCheckAlsPpSupportIPC, KErrNone, completeData);
customAPI.CheckAlsPpSupport(reguestStatus, alsSupport);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
ASSERT_EQUALS(completeAlsSupport2, alsSupport);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::CheckAlsPpSupport
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomCheckAlsPpSupportIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCAPS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::CheckAlsPpSupport
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::CheckAlsPpSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckAlsPpSupport0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for CompleteL
RMmCustomAPI::TAlsSupport completeAlsSupport(RMmCustomAPI::EAlsSupportOff);
TMockLtsyData1< RMmCustomAPI::TAlsSupport > ltsyData(completeAlsSupport);
ltsyData.SerialiseL(completeData);
// data for CheckAlsPpSupport itself
TRequestStatus reguestStatus;
RMmCustomAPI::TAlsSupport alsSupport;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::CheckAlsPpSupport
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.CompleteL(ECustomCheckAlsPpSupportIPC, KErrNone, completeData, 20);
customAPI.CheckAlsPpSupport(reguestStatus, alsSupport);
customAPI.CancelAsyncRequest(ECustomCheckAlsPpSupportIPC);
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrCancel, reguestStatus.Int());
// Wait for completion of iMockLTSY.NotifyTerminated
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCAPS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::CheckAlsPpSupport
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::CheckAlsPpSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckAlsPpSupport0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RBuf8 completeData2;
CleanupClosePushL(completeData2);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
// data for the first CompleteL
RMmCustomAPI::TAlsSupport completeAlsSupport(RMmCustomAPI::EAlsSupportOff);
TMockLtsyData1< RMmCustomAPI::TAlsSupport > ltsyData(completeAlsSupport);
ltsyData.SerialiseL(completeData);
// data for the first CheckAlsPpSupport itself
TRequestStatus reguestStatus;
RMmCustomAPI::TAlsSupport alsSupport;
// data for the second CheckAlsPpSupport itself
TRequestStatus reguestStatus2;
RMmCustomAPI::TAlsSupport alsSupport2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::CheckAlsPpSupport
//-------------------------------------------------------------------------
// send first request
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.CompleteL(ECustomCheckAlsPpSupportIPC, KErrNone, completeData, 10);
customAPI.CheckAlsPpSupport(reguestStatus, alsSupport);
// send second request
customAPI2.CheckAlsPpSupport(reguestStatus2, alsSupport2);
// wait for the first answer
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrNone, reguestStatus.Int());
ASSERT_EQUALS(completeAlsSupport, alsSupport);
// wait for the second answer
User::WaitForRequest(reguestStatus2);
ASSERT_EQUALS(KErrNone, reguestStatus2.Int());
ASSERT_EQUALS(completeAlsSupport, alsSupport2);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCAPS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckAlsPpSupport with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckAlsPpSupport and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckAlsPpSupport0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// data for CheckAlsPpSupport itself
TRequestStatus reguestStatus;
RMmCustomAPI::TAlsSupport alsSupport;
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::CheckAlsPpSupport
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
customAPI.CheckAlsPpSupport(reguestStatus, alsSupport);
// There is no time out for this IPC (ECustomCheckAlsPpSupportIPC)
User::WaitForRequest(reguestStatus);
ASSERT_EQUALS(KErrTimedOut, reguestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGRATS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetRemoteAlertingToneStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetRemoteAlertingToneStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetRemoteAlertingToneStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// TEST Get initial toneStatus
//-------------------------------------------------------------------------
RMmCustomAPI::TRemoteAlertingToneStatus expectedStatus(RMmCustomAPI::EUiNoTone);
RMmCustomAPI::TRemoteAlertingToneStatus toneStatus;
customAPI.GetRemoteAlertingToneStatus(toneStatus);
ASSERT_EQUALS(expectedStatus, toneStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST D: RMmCustomAPI::GetRemoteAlertingToneStatus again, this time CTSY
// will get result from the cache.
//-------------------------------------------------------------------------
// --- change tone status ---
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
// data for changing
TBool playRemoteAlertToneLocally (ETrue);
TMockLtsyData1<TBool> ltsyData(playRemoteAlertToneLocally);
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetRemoteAlertingToneStatusIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// new expected Status
expectedStatus = RMmCustomAPI::EUiRbtTone;
// --------------------------
// get changed data
customAPI.GetRemoteAlertingToneStatus(toneStatus);
ASSERT_EQUALS(expectedStatus, toneStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST D2: just for coverage increasing
//-------------------------------------------------------------------------
// --- change tone status ---
iMockLTSY.NotifyTerminated(mockLtsyStatus);
// data for changing
playRemoteAlertToneLocally = EFalse;
TMockLtsyData1<TBool> ltsyData2(playRemoteAlertToneLocally);
completeData.Close();
ltsyData2.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetRemoteAlertingToneStatusIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// new expected Status
expectedStatus = RMmCustomAPI::EUiStopTone;
// --------------------------
// get changed data
customAPI.GetRemoteAlertingToneStatus(toneStatus);
ASSERT_EQUALS(expectedStatus, toneStatus);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCO-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CallOrigin
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CallOrigin
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCallOrigin0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 completeData;
CleanupClosePushL(completeData);
// data for CallOrigin itself
TName callName;
RMmCustomAPI::TCallOrigin origin;
//-------------------------------------------------------------------------
// TEST: Get origin for non-existing call
//-------------------------------------------------------------------------
customAPI.CallOrigin(callName, origin);
ASSERT_EQUALS(RMmCustomAPI::EUnknown, origin);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST: Get origin for call created through ETel
//-------------------------------------------------------------------------
RLine line;
RCall call;
// Open Line and Call
TInt errorCode = line.Open(iPhone, KMmTsyVoice1LineName);
ASSERT_EQUALS(KErrNone, errorCode);
CleanupClosePushL(line);
TInt callId = 1;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
// create new incoming call
errorCode = CreateIncomingCallL(line, callId, KMmTsyVoice1LineName,callName,
mobileService, mobileCallStatus);
ASSERT_EQUALS(KErrNone, errorCode);
CleanupClosePushL(call);
errorCode = call.OpenExistingCall(line, callName);
ASSERT_EQUALS(KErrNone, errorCode);
//Get origin for call created through ETel
customAPI.CallOrigin(callName, origin);
ASSERT_EQUALS(RMmCustomAPI::EETelCall, origin);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST: Get origin for Ghost call (NOT created through ETel)
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
// for getting ghost call name
TName ghostCallName;
line.NotifyCallAdded(requestStatus, ghostCallName);
// ------------ Create ghost call -----------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
RMobileCall::TMobileCallInfoV1 callInfo;
callId = 2;
callInfo.iCallId = callId;
callInfo.iStatus = RMobileCall::EStatusDialling;
callInfo.iService = mobileService;
TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(callId, mobileService, callInfo);
callInfoData.SerialiseL(completeData);
iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
// wait for NotifyCallAdded (for getting ghost call name)
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//Get origin for call NOT created through ETel
customAPI.CallOrigin(ghostCallName, origin);
ASSERT_EQUALS(RMmCustomAPI::EOutsider, origin);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCTC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::TerminateCall
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::TerminateCall
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestTerminateCall0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TName callName;
TBool isError(ETrue);
TInt callId(1);
RLine line;
RCall call;
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
OpenLineLC(line, iPhone, KMmTsyVoice1LineName);
CreateAndOpenIncomingCalLC(line, call, callName, KMmTsyVoice1LineName,
callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
TMockLtsyData2<TInt, TBool> mockData2(callId, isError);
mockData2.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomTerminateCallIPC, expectData, KErrNotSupported);
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomTerminateCallIPC, expectData);
iMockLTSY.CompleteL(ECustomTerminateCallIPC, KErrGeneral);
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::TerminateCall when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomTerminateCallIPC, expectData, KErrNone);
iMockLTSY.CompleteL(ECustomTerminateCallIPC, KErrNone);
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::TerminateCall
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomTerminateCallIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
// TerminateCall with KTerminateAllCalls
//-------------------------------------------------------------------------
callName.Copy(KTerminateAllCalls);
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TerminateCall with KTerminateAllCalls when there is a call with EStatusConnecting
//-------------------------------------------------------------------------
RCall call2;
callId = 2;
CreateAndOpenIncomingCalLC(line, call2, callName, KMmTsyVoice1LineName,
callId, RMobileCall::EStatusConnecting, RMobilePhone::EVoiceService);
callName.Copy(KTerminateAllCalls);
callId = (-callId);
isError = EFalse;
TMockLtsyData2<TInt, TBool> mockData2b(callId, isError);
expectData.Close();
mockData2b.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomTerminateCallIPC, expectData, KErrNone);
iMockLTSY.CompleteL(ECustomTerminateCallIPC, KErrNone);
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCTC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::TerminateCall
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::TerminateCall
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestTerminateCall0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TName callName;
TBool isError(ETrue);
TInt callId(1);
RLine line;
RCall call;
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
OpenLineLC(line, iPhone, KMmTsyVoice1LineName);
CreateAndOpenIncomingCalLC(line, call, callName, KMmTsyVoice1LineName,
callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::TerminateCall
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TMockLtsyData2<TInt, TBool> mockData2(callId, isError);
mockData2.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomTerminateCallIPC, expectData);
iMockLTSY.CompleteL(ECustomTerminateCallIPC, KErrNone, 10);
customAPI.TerminateCall(requestStatus, callName);
customAPI.CancelAsyncRequest(ECustomTerminateCallIPC);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCTC-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::TerminateCall with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::TerminateCall with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestTerminateCall0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TName callName;
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test passing callName with length equals null
//-------------------------------------------------------------------------
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotFound, requestStatus.Int());
//-------------------------------------------------------------------------
// Test A: Test passing wrong version of parameters to
// RMmCustomAPI::TerminateCall
//-------------------------------------------------------------------------
_LIT(KBadParam, "Bad name");
callName.Copy(KBadParam);
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotFound, requestStatus.Int());
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCTC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::TerminateCall
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::TerminateCall
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestTerminateCall0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
//-------------------------------------------------------------------------
// Calls of functions for first client.
//-------------------------------------------------------------------------
TName callName1;
TBool isError(ETrue);
TInt callId1(1);
RLine line1;
RCall call1;
RMmCustomAPI customAPI1;
OpenCustomAPILC(customAPI1, iPhone);
OpenLineLC(line1, iPhone, KMmTsyVoice1LineName);
CreateAndOpenIncomingCalLC(line1, call1, callName1, KMmTsyVoice1LineName,
callId1, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
//-------------------------------------------------------------------------
// Calls of functions for second client.
//-------------------------------------------------------------------------
TName callName2;
TInt callId2(2);
RLine line2;
RCall call2;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
OpenLineLC(line2, phone2, KMmTsyVoice1LineName);
CreateAndOpenIncomingCalLC(line2, call2, callName2, KMmTsyVoice1LineName,
callId2, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::TerminateCall
//-------------------------------------------------------------------------
TMockLtsyData2<TInt, TBool> mockData21(callId1, isError);
mockData21.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomTerminateCallIPC, expectData, KErrNone);
iMockLTSY.CompleteL(ECustomTerminateCallIPC, KErrNone, 20);
customAPI1.TerminateCall(requestStatus1, callName1);
customAPI2.TerminateCall(requestStatus2, callName2);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(10, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCTC-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::TerminateCall with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::TerminateCall and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestTerminateCall0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
TName callName;
TBool isError(ETrue);
TInt callId(1);
RLine line;
RCall call;
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
OpenLineLC(line, iPhone, KMmTsyVoice1LineName);
CreateAndOpenIncomingCalLC(line, call, callName, KMmTsyVoice1LineName,
callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::TerminateCall
//-------------------------------------------------------------------------
TMockLtsyData2<TInt, TBool> mockData2(callId, isError);
mockData2.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomTerminateCallIPC, expectData, KErrNone);
customAPI.TerminateCall(requestStatus, callName);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCBABC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyAlsBlockedChanged
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyAlsBlockedChanged
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyAlsBlockedChanged0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
RMmCustomAPI::TGetAlsBlockStatus completeBlockStatus;
RMmCustomAPI::TSetAlsBlock blockStatus(RMmCustomAPI::EActivateBlock);
RMmCustomAPI customAPI;
RBuf8 expectData;
CleanupClosePushL(expectData);
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyAlsBlockedChanged
// from LTSY.
// Must be first because the request is self-reposting
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyAlsBlockedChangedIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyAlsBlockedChanged when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyAlsBlockedChanged(requestStatus, completeBlockStatus);
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData(blockStatus);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone);
TRequestStatus requestStatus2;
customAPI.SetAlsBlocked(requestStatus2, blockStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
AssertMockLtsyStatusL();
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(RMmCustomAPI::EBlockStatusActive, completeBlockStatus);
//-------------------------------------------------------------------------
// for coverage increasing
//-------------------------------------------------------------------------
customAPI.NotifyAlsBlockedChanged(requestStatus, completeBlockStatus);
blockStatus = RMmCustomAPI::EDeactivateBlock;
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone);
customAPI.SetAlsBlocked(requestStatus2, blockStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
AssertMockLtsyStatusL();
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(RMmCustomAPI::EBlockStatusInactive, completeBlockStatus);
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCBABC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyAlsBlockedChanged
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyAlsBlockedChanged
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyAlsBlockedChanged0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TGetAlsBlockStatus completeBlockStatus;
RMmCustomAPI::TSetAlsBlock blockStatus(RMmCustomAPI::EActivateBlock);
RMmCustomAPI customAPI;
RBuf8 expectData;
CleanupClosePushL(expectData);
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyAlsBlockedChanged
//-------------------------------------------------------------------------
customAPI.NotifyAlsBlockedChanged(requestStatus, completeBlockStatus);
customAPI.CancelAsyncRequest(ECustomNotifyAlsBlockedChangedIPC);
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData(blockStatus);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone);
customAPI.SetAlsBlocked(requestStatus2, blockStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCBABC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyAlsBlockedChanged
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyAlsBlockedChanged
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyAlsBlockedChanged0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TRequestStatus reqStatus;
RMmCustomAPI::TGetAlsBlockStatus completeBlockStatus1;
RMmCustomAPI::TGetAlsBlockStatus completeBlockStatus2;
RMmCustomAPI::TSetAlsBlock activateBlockStatus(RMmCustomAPI::EActivateBlock);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
RBuf8 expectData;
CleanupClosePushL(expectData);
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyAlsBlockedChanged
//-------------------------------------------------------------------------
customAPI1.NotifyAlsBlockedChanged(requestStatus1, completeBlockStatus1);
customAPI2.NotifyAlsBlockedChanged(requestStatus2, completeBlockStatus2);
TMockLtsyData1< RMmCustomAPI::TSetAlsBlock > ltsyData(activateBlockStatus);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSetAlsBlockedIPC, expectData);
iMockLTSY.CompleteL(ECustomSetAlsBlockedIPC, KErrNone);
customAPI1.SetAlsBlocked(reqStatus, activateBlockStatus);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone, reqStatus.Int());
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(RMmCustomAPI::EBlockStatusActive, completeBlockStatus1);
ASSERT_EQUALS(RMmCustomAPI::EBlockStatusActive, completeBlockStatus2);
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCipheringInfo
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetCipheringInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCipheringInfo0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
RMmCustomAPI::TCipheringInfo info;
TBool indReq(ETrue);
TPckg<TBool> pckgIndReq(indReq);
//-------------------------------------------------------------------------
// TEST D: RMmCustomAPI::GetCipheringInfo again, this time CTSY
// will get result from the cache.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetCipheringInfoIPC);
iMockLTSY.CompleteL(ECustomGetCipheringInfoIPC, KErrNone, pckgIndReq);
customAPI.GetCipheringInfo(requestStatus, info);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(indReq, info.iIndStatus);
ASSERT_TRUE(EFalse == info.iCiphStatus);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetCipheringInfoIPC, 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(ECustomGetCipheringInfoIPC);
iMockLTSY.CompleteL(ECustomGetCipheringInfoIPC, KErrGeneral, pckgIndReq);
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 strInfo;
strInfo.iCiphStatus = ETrue;
TPckg<RMmCustomAPI::TCipheringInfo> pckg(strInfo);
iMockLTSY.CompleteL(ECustomNotifyCipheringInfoChangeIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
iMockLTSY.ExpectL(ECustomGetCipheringInfoIPC);
iMockLTSY.CompleteL(ECustomGetCipheringInfoIPC, KErrNone, pckgIndReq);
customAPI.GetCipheringInfo(requestStatus, info);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(indReq, info.iIndStatus);
ASSERT_EQUALS(strInfo.iCiphStatus, info.iCiphStatus);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetCipheringInfo
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetCipheringInfoIPC, KErrNone, pckgIndReq);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetCipheringInfo
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetCipheringInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCipheringInfo0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
RMmCustomAPI::TCipheringInfo info;
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TBool indReq(ETrue);
TPckg<TBool> pckgIndReq(indReq);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetCipheringInfo
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.ExpectL(ECustomGetCipheringInfoIPC);
iMockLTSY.CompleteL(ECustomGetCipheringInfoIPC, KErrNone, pckgIndReq, 10);
customAPI.GetCipheringInfo(requestStatus, info);
customAPI.CancelAsyncRequest(ECustomGetCipheringInfoIPC);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetCipheringInfo
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetCipheringInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCipheringInfo0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
RMmCustomAPI::TCipheringInfo info1;
RMmCustomAPI::TCipheringInfo info2;
TBool ciphStatus(EFalse);
TBool indReq(ETrue);
TPckg<TBool> pckgIndReq(indReq);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetCipheringInfo
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetCipheringInfoIPC);
iMockLTSY.CompleteL(ECustomGetCipheringInfoIPC, KErrNone, pckgIndReq);
customAPI1.GetCipheringInfo(requestStatus1, info1);
customAPI2.GetCipheringInfo(requestStatus2, info2);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
ASSERT_EQUALS(indReq, info1.iIndStatus);
ASSERT_EQUALS(ciphStatus, info1.iCiphStatus);
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCipheringInfo with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetCipheringInfo and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCipheringInfo0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TCipheringInfo info;
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::GetCipheringInfo
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetCipheringInfoIPC);
customAPI.GetCipheringInfo(requestStatus, info);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNCIC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyCipheringInfoChange
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyCipheringInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyCipheringInfoChange0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
RMmCustomAPI::TCipheringInfo info;
RMmCustomAPI::TCipheringInfo completeInfo;
completeInfo.iIndStatus = ETrue;
completeInfo.iCiphStatus = ETrue;
TPckg<RMmCustomAPI::TCipheringInfo> pckg(completeInfo);
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyCipheringInfoChange when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyCipheringInfoChange(requestStatus, info);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyCipheringInfoChangeIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
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(ECustomNotifyCipheringInfoChangeIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNCIC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyCipheringInfoChange
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyCipheringInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyCipheringInfoChange0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
RMmCustomAPI::TCipheringInfo info;
RMmCustomAPI::TCipheringInfo completeInfo;
completeInfo.iIndStatus = ETrue;
completeInfo.iCiphStatus = ETrue;
TPckg<RMmCustomAPI::TCipheringInfo> pckg(completeInfo);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyCipheringInfoChange
//-------------------------------------------------------------------------
customAPI.NotifyCipheringInfoChange(requestStatus, info);
customAPI.CancelAsyncRequest(ECustomNotifyCipheringInfoChangeIPC);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyCipheringInfoChangeIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNCIC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyCipheringInfoChange
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyCipheringInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyCipheringInfoChange0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TRequestStatus mockLtsyStatus;
RMmCustomAPI::TCipheringInfo info1;
RMmCustomAPI::TCipheringInfo info2;
RMmCustomAPI::TCipheringInfo completeInfo;
completeInfo.iIndStatus = ETrue;
completeInfo.iCiphStatus = ETrue;
TPckg<RMmCustomAPI::TCipheringInfo> pckg(completeInfo);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyCipheringInfoChange
//-------------------------------------------------------------------------
customAPI1.NotifyCipheringInfoChange(requestStatus1, info1);
customAPI2.NotifyCipheringInfoChange(requestStatus2, info2);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyCipheringInfoChangeIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(completeInfo.iIndStatus, info1.iIndStatus);
ASSERT_EQUALS(completeInfo.iCiphStatus, info1.iCiphStatus);
ASSERT_EQUALS(completeInfo.iIndStatus, info2.iIndStatus);
ASSERT_EQUALS(completeInfo.iCiphStatus, info2.iCiphStatus);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNNS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyNSPSStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyNSPSStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyNSPSStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TBool nspsIsOn(ETrue);
TPckg<TBool> pckg(nspsIsOn);
RMmCustomAPI::TNspsStatus nspsStatus;
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyNSPSStatus
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyNSPSStatusIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyNSPSStatus when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyNSPSStatus(requestStatus, nspsStatus);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyNSPSStatusIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(RMmCustomAPI::ENspsOn, nspsStatus);
//-------------------------------------------------------------------------
// for coverage increasing
//-------------------------------------------------------------------------
customAPI.NotifyNSPSStatus(requestStatus, nspsStatus);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
nspsIsOn = EFalse;
iMockLTSY.CompleteL(ECustomNotifyNSPSStatusIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(RMmCustomAPI::ENspsOff, nspsStatus);
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNNS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyNSPSStatus
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyNSPSStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyNSPSStatus0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TBool nspsIsOn(ETrue);
TPckg<TBool> pckg(nspsIsOn);
RMmCustomAPI::TNspsStatus nspsStatus;
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyNSPSStatus
//-------------------------------------------------------------------------
customAPI.NotifyNSPSStatus(requestStatus, nspsStatus);
customAPI.CancelAsyncRequest(ECustomNotifyNSPSStatusIPC);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyNSPSStatusIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNNS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyNSPSStatus
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyNSPSStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyNSPSStatus0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
TRequestStatus mockLtsyStatus;
TBool nspsIsOn(ETrue);
TPckg<TBool> pckg(nspsIsOn);
RMmCustomAPI::TNspsStatus nspsStatus1;
RMmCustomAPI::TNspsStatus nspsStatus2;
RMmCustomAPI::TNspsStatus nspsOn(RMmCustomAPI::ENspsOn);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyNSPSStatus
//-------------------------------------------------------------------------
customAPI1.NotifyNSPSStatus(requestStatus1, nspsStatus1);
customAPI2.NotifyNSPSStatus(requestStatus2, nspsStatus2);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyNSPSStatusIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(nspsOn, nspsStatus1);
ASSERT_EQUALS(nspsOn, nspsStatus2);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNW-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NetWakeup
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NetWakeup
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNetWakeup0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomNetWakeupIPC, KErrNotSupported);
customAPI.NetWakeup(requestStatus);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomNetWakeupIPC);
iMockLTSY.CompleteL(ECustomNetWakeupIPC, KErrGeneral);
customAPI.NetWakeup(requestStatus);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NetWakeup when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomNetWakeupIPC);
iMockLTSY.CompleteL(ECustomNetWakeupIPC, KErrNone);
customAPI.NetWakeup(requestStatus);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NetWakeup
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNetWakeupIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNW-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NetWakeup
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NetWakeup
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNetWakeup0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NetWakeup
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.ExpectL(ECustomNetWakeupIPC);
iMockLTSY.CompleteL(ECustomNetWakeupIPC, KErrNone, 10);
customAPI.NetWakeup(requestStatus);
customAPI.CancelAsyncRequest(ECustomNetWakeupIPC);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNW-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NetWakeup
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NetWakeup
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNetWakeup0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NetWakeup
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomNetWakeupIPC);
iMockLTSY.CompleteL(ECustomNetWakeupIPC, KErrNone);
customAPI1.NetWakeup(requestStatus1);
iMockLTSY.ExpectL(ECustomNetWakeupIPC);
iMockLTSY.CompleteL(ECustomNetWakeupIPC, KErrNone);
customAPI2.NetWakeup(requestStatus2);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNW-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NetWakeup with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NetWakeup and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNetWakeup0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::NetWakeup
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomNetWakeupIPC);
customAPI.NetWakeup(requestStatus);
/*
* Test support in CTSY for RmobilePhone::GetServiceTable with timeout
* IS ABOUT TO ABORT DUE TO TEF TIMEOUT.
*/
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 401601);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(2, this);
}
void CCTsyCustomIPCFU::FillWithRandomDataLC( RMmCustomAPI::TViagElements*& aElem, TInt aRnd) const
{
aElem = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(aElem);
_LIT(KName, "Name");
RMmCustomAPI::TViagElement element;
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
element.iActiveFlag = ( i%2 == 0 ) ? RMmCustomAPI::ECityZone : RMmCustomAPI::ENotActive;
element.iCoordinates.iR2 = 2*i + aRnd;
element.iCoordinates.iX = i + aRnd;
element.iCoordinates.iY = RMmCustomAPI::KViagElementCount - i + aRnd;
element.iCoordinates.iZoneId = 2*i + 1 + aRnd;
element.iName = KName;
TBuf<2> number;
number.Format(_L("%d"), i + aRnd);
element.iName.Append(number);
aElem->AppendL(element);
}
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZP-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneParams
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneParams
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneParams0001L()
{
AuxReadViagHomeZoneParamsL();
/*
* Test increases CMmSIMTsy::ReadViagHomeZoneParamsL coverage
* covers "if ( iMmCustomTsy->Phone()->NosBootState()->iSIMReady )" condition
*/
AuxReadViagHomeZoneParamsForIncreasingCoverageL();
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZP-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ReadViagHomeZoneParams
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::ReadViagHomeZoneParams
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneParams0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 completeData;
CleanupClosePushL(completeData);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
RMmCustomAPI::TViagElement element;
_LIT(KScp, "Lenin lives!");
_LIT(KSmsC, "revolution");
// Variables for call ReadViagHomeZoneParams.
RMmCustomAPI::TViagParams param;
RMmCustomAPI::TViagElements* elems;
elems = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(elems);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
elems->AppendL(element);
}
// Variables for call CompleteL.
RMmCustomAPI::TViagParams completeParam;
completeParam.iScp = KScp;
completeParam.iSmsC = KSmsC;
completeParam.iSubscribedZoneAndVersion = 17;
RMmCustomAPI::TViagElements* completeElems;
FillWithRandomDataLC(completeElems);
TMockLtsyData2<RMmCustomAPI::TViagParams, RMmCustomAPI::TViagElements*>
mockData2(completeParam, completeElems);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::ReadViagHomeZoneParams
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.ExpectL(EReadViagHomeZoneParamsIPC);
mockData2.SerialiseL(completeData);
iMockLTSY.CompleteL(EReadViagHomeZoneParamsIPC, KErrNone, completeData, 10);
customAPI.ReadViagHomeZoneParams(requestStatus, param, *elems);
customAPI.CancelAsyncRequest(EReadViagHomeZoneParamsIPC);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZP-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneParams with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneParams with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneParams0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
// Variables for call ReadViagHomeZoneParams.
RMmCustomAPI::TViagParams param;
RMmCustomAPI::TViagElements* elems = NULL;
elems = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(elems);
//-------------------------------------------------------------------------
// Test C: Test passing out of bounds parameters to
// RMmCustomAPI::ReadViagHomeZoneParams
//-------------------------------------------------------------------------
customAPI.ReadViagHomeZoneParams(requestStatus, param, *elems);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZP-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ReadViagHomeZoneParams
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::ReadViagHomeZoneParams
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneParams0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
RBuf8 completeData;
CleanupClosePushL(completeData);
TRequestStatus requestStatus1;
TRequestStatus requestStatus2;
RMmCustomAPI::TViagElement element;
_LIT(KScp, "Lenin lives!");
_LIT(KSmsC, "revolution");
// Variables for call ReadViagHomeZoneParams of first client.
RMmCustomAPI::TViagParams param1;
RMmCustomAPI::TViagElements* elems1 = NULL;
elems1 = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(elems1);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
elems1->AppendL(element);
}
// Variables for call ReadViagHomeZoneParams of second client.
RMmCustomAPI::TViagParams param2;
RMmCustomAPI::TViagElements* elems2 = NULL;
elems2 = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(elems2);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
elems2->AppendL(element);
}
// Variables for call CompleteL.
RMmCustomAPI::TViagParams completeParam;
completeParam.iScp = KScp;
completeParam.iSmsC = KSmsC;
completeParam.iSubscribedZoneAndVersion = 17;
RMmCustomAPI::TViagElements* completeElems;
FillWithRandomDataLC(completeElems);
TMockLtsyData2<RMmCustomAPI::TViagParams, RMmCustomAPI::TViagElements*>
mockData2(completeParam, completeElems);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::ReadViagHomeZoneParams
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EReadViagHomeZoneParamsIPC);
mockData2.SerialiseL(completeData);
iMockLTSY.CompleteL(EReadViagHomeZoneParamsIPC, KErrNone, completeData);
customAPI1.ReadViagHomeZoneParams(requestStatus1, param1, *elems1);
customAPI2.ReadViagHomeZoneParams(requestStatus2, param2, *elems2);
User::WaitForRequest(requestStatus1);
ASSERT_EQUALS(KErrNone, requestStatus1.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
ASSERT_EQUALS(0, completeParam.iScp.Compare(param1.iScp));
ASSERT_EQUALS(0, completeParam.iSmsC.Compare(param1.iSmsC));
ASSERT_EQUALS(completeParam.iSubscribedZoneAndVersion, param1.iSubscribedZoneAndVersion);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
ASSERT_EQUALS(completeElems->At(i).iActiveFlag , elems1->At(i).iActiveFlag );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iR2 , elems1->At(i).iCoordinates.iR2 );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iX , elems1->At(i).iCoordinates.iX );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iY , elems1->At(i).iCoordinates.iY );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iZoneId, elems1->At(i).iCoordinates.iZoneId);
ASSERT_EQUALS(0, completeElems->At(i).iName.Compare(elems1->At(i).iName));
}
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(9, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZP-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneParams with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneParams and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneParams0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TViagElement element;
// Variables for call ReadViagHomeZoneParams.
RMmCustomAPI::TViagParams param;
RMmCustomAPI::TViagElements* elems = NULL;
elems = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(elems);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
elems->AppendL(element);
}
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::ReadViagHomeZoneParams
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EReadViagHomeZoneParamsIPC);
customAPI.ReadViagHomeZoneParams(requestStatus, param, *elems);
/*
* Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneParams with timeout
* IS ABOUT TO ABORT DUE TO TEF TIMEOUT.
*/
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 401702);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneCache0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
RMmCustomAPI customAPI;
//----------------------------------------------
// TEST D: CTSY will get results from the cache.
//----------------------------------------------
//********************************************************************************
//* To initialize the VIAG home zone cache properly RMmCustomAPI::OpenL should be
//* invoked _before_ EMmTsyBootNotifySimStatusReadyIPC is triggered.
//* That's why OpenPhoneAndCustomAPILC was implemented and is used here
//* instead of usual OpenPhoneL/OpenCustomAPILC sequence.
//********************************************************************************
OpenPhoneAndCustomAPILC(customAPI);
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMin; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
RMmCustomAPI::TViagCacheRecordId recId;
recId.iCacheId = c;
recId.iRecordId = r;
RMmCustomAPI::TViagCacheRecordContent recContent;
TRequestStatus reqStatus;
customAPI.ReadViagHomeZoneCache(reqStatus,recId,recContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone,reqStatus.Int());
const RMmCustomAPI::TViagCacheRecordContent& expectedContent =
iViagHomeZoneCache[c - KViagHomeZoneCacheIdMin][r - KViagHomeZoneCacheRecordIdMin];
ASSERT_EQUALS(expectedContent.iLac, recContent.iLac);
ASSERT_EQUALS(expectedContent.iCellId, recContent.iCellId);
}
}
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::ReadViagHomeZoneCache
// from LTSY.
//-------------------------------------------------------------------------
// unsolicited EReadViagHomeZoneCacheIPC completion crashes CTSY
RMmCustomAPI::TViagCacheRecordContent unsolicitedData;
TPckgC<RMmCustomAPI::TViagCacheRecordContent> unsolicitedDataPckg(unsolicitedData);
unsolicitedData.iCellId = 111;
unsolicitedData.iLac = 222;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EReadViagHomeZoneCacheIPC,KErrNone,unsolicitedDataPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZC-0001b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneCache when request failed by NTSY
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneCache0001bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
RMmCustomAPI customAPI;
//********************************************************************************
//* To initialize the VIAG home zone cache properly RMmCustomAPI::OpenL should be
//* invoked _before_ EMmTsyBootNotifySimStatusReadyIPC is triggered.
//* That's why OpenPhoneAndCustomAPILC was implemented and is used here
//* instead of usual OpenPhoneL/OpenCustomAPILC sequence.
//********************************************************************************
OpenPhoneAndCustomAPILC(customAPI, KErrGeneral);
// Complete with an error
MockPrimeEReadViagHomeZoneCacheIPCL(KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMin, ETrue, ETrue, KErrGeneral);
RMmCustomAPI::TViagCacheRecordContent recContent;
TRequestStatus reqStatus;
RMmCustomAPI::TViagCacheRecordId recId;
recId.iCacheId = 2;
recId.iRecordId = 2;
customAPI.ReadViagHomeZoneCache(reqStatus, recId, recContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrGeneral,reqStatus.Int());
//complete without an error
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMax; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
MockPrimeEReadViagHomeZoneCacheIPCL(c,r, ETrue, ETrue, KErrNone);
}
}
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMin; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
recId.iCacheId = c;
recId.iRecordId = r;
customAPI.ReadViagHomeZoneCache(reqStatus,recId,recContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone,reqStatus.Int());
const RMmCustomAPI::TViagCacheRecordContent& expectedContent =
iViagHomeZoneCache[c - KViagHomeZoneCacheIdMin][r - KViagHomeZoneCacheRecordIdMin];
ASSERT_EQUALS(expectedContent.iLac, recContent.iLac);
ASSERT_EQUALS(expectedContent.iCellId, recContent.iCellId);
}
}
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZC-0001c
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneCache when request complete when customAPI is dead
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneCache0001cL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
RBuf8 data;
data.CleanupClosePushL();
RMmCustomAPI customAPI;
CleanupClosePushL(customAPI);
TInt err = iPhone.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, err);
err=iMockLTSY.Connect();
ASSERT_EQUALS(KErrNone, err);
RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
currentlyRetrievedCache.iCacheId = 1;
currentlyRetrievedCache.iRecordId = 0;
TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyData(currentlyRetrievedCache);
// Only Expect, no complete
MockPrimeEReadViagHomeZoneCacheIPCL(KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMin, EFalse, ETrue );
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//************************************************************
//* Invoke RMmCustomAPI::Open prior to triggering any further
//* CTSY events including EMmTsyBootNotifySimStatusReadyIPC
//************************************************************
err = customAPI.Open(iPhone);
ASSERT_EQUALS(KErrNone, err);
// EMmTsyBootNotifyModemStatusReadyIPC
iMockLTSY.CompleteL(EMmTsyBootNotifyModemStatusReadyIPC,KErrNone);
// EMobilePhoneGetNetworkRegistrationStatus
iMockLTSY.ExpectL(EMobilePhoneGetNetworkRegistrationStatus);
iMockLTSY.CompleteL(EMobilePhoneGetNetworkRegistrationStatus,KErrNone,0);
// EMmTsyBootNotifySimStatusReadyIPC
iMockLTSY.ExpectL(EMmTsyBootNotifySimStatusReadyIPC);
iMockLTSY.CompleteL(EMmTsyBootNotifySimStatusReadyIPC,KErrNone,0);
// EMobilePhoneGetHomeNetwork
RMobilePhone::TMobilePhoneNetworkInfoV5 homeNetwork;
homeNetwork.iMode = RMobilePhone::ENetworkModeWcdma;
homeNetwork.iStatus = RMobilePhone::ENetworkStatusCurrent;
homeNetwork.iBandInfo = RMobilePhone::EBandUnknown;
homeNetwork.iCountryCode = _L("234");
homeNetwork.iCdmaSID = _L("");
homeNetwork.iAnalogSID = _L("");
homeNetwork.iNetworkId = _L("23499");
homeNetwork.iDisplayTag = _L("symbian");
homeNetwork.iShortName = _L("symbian");
homeNetwork.iLongName = _L("symbian mobile");
homeNetwork.iAccess = RMobilePhone::ENetworkAccessUtran;
homeNetwork.iEgprsAvailableIndicator = ETrue;
homeNetwork.iHsdpaAvailableIndicator = ETrue;
TMockLtsyData1<RMobilePhone::TMobilePhoneNetworkInfoV5> homeNetworkData(homeNetwork);
homeNetworkData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetHomeNetwork);
iMockLTSY.CompleteL(EMobilePhoneGetHomeNetwork,KErrNone,data,0);
// EMmTsyPhoneGetPin1DisableSupportedIPC
TBool pin1DisableSupport = ETrue;
TMockLtsyData1<TBool> pin1DisableSupportData(pin1DisableSupport);
data.Close();
pin1DisableSupportData.SerialiseL(data);
iMockLTSY.ExpectL(EMmTsyPhoneGetPin1DisableSupportedIPC);
iMockLTSY.CompleteL(EMmTsyPhoneGetPin1DisableSupportedIPC,KErrNone,data,0);
// EMmTsySimRefreshRegisterIPC
iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);
// EMobilePhoneGetServiceTable
RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::ESIMServiceTable;
TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTable> serviceTableData(serviceTable);
data.Close();
serviceTableData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetServiceTable, 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<RMobilePhone::TMobilePhoneServiceTableV1> serviceTableResultData(serviceTableResult);
data.Close();
serviceTableResultData.SerialiseL(data);
iMockLTSY.CompleteL(EMobilePhoneGetServiceTable,KErrNone,data,0);
// EMobilePhoneGetALSLine
RMobilePhone::TMobilePhoneALSLine alsLine = RMobilePhone::EAlternateLinePrimary;
TMockLtsyData1<RMobilePhone::TMobilePhoneALSLine> alsLineData(alsLine);
data.Close();
alsLineData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetALSLine);
iMockLTSY.CompleteL(EMobilePhoneGetALSLine,KErrNone,data,0);
// ECustomGetIccCallForwardingStatusIPC
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
// EMobilePhoneGetIccMessageWaitingIndicators
RMobilePhone::TMobilePhoneMessageWaitingV1 expectedMessageIndicators;
TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1>
indicatorsData(expectedMessageIndicators);
data.Close();
indicatorsData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetIccMessageWaitingIndicators);
iMockLTSY.CompleteL(EMobilePhoneGetIccMessageWaitingIndicators, KErrNone, data);
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.ExpectL(EMobilePhoneGetCustomerServiceProfile);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// Close the customAPI.
CleanupStack::PopAndDestroy(&customAPI);
// Wait for server to clear...
User::After(KOneSecond);
// ECustomGetIccCallForwardingStatusIPC
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMax; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
MockPrimeEReadViagHomeZoneCacheIPCL(c,r, ETrue, ETrue, KErrNone);
}
}
// Open another client
RMmCustomAPI customAPI2;
CleanupClosePushL(customAPI2);
ASSERT_EQUALS(KErrNone,customAPI2.Open(iPhone));
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMin; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
TRequestStatus reqStatus;
RMmCustomAPI::TViagCacheRecordId recId;
recId.iCacheId = c;
recId.iRecordId = r;
RMmCustomAPI::TViagCacheRecordContent recContent;
customAPI2.ReadViagHomeZoneCache(reqStatus,recId,recContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone,reqStatus.Int());
const RMmCustomAPI::TViagCacheRecordContent& expectedContent =
iViagHomeZoneCache[c - KViagHomeZoneCacheIdMin][r - KViagHomeZoneCacheRecordIdMin];
ASSERT_EQUALS(expectedContent.iLac, recContent.iLac);
ASSERT_EQUALS(expectedContent.iCellId, recContent.iCellId);
}
}
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this); // customAPI2, data, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneCache0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus reqStatus;
RMmCustomAPI::TViagCacheRecordId recId;
recId.iCacheId = KViagHomeZoneCacheIdMax;
recId.iRecordId = KViagHomeZoneCacheRecordIdMax;
RMmCustomAPI::TViagCacheRecordContent recContent;
customAPI.ReadViagHomeZoneCache(reqStatus,recId,recContent);
customAPI.CancelAsyncRequest(EReadViagHomeZoneCacheIPC);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrCancel, reqStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZC-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneCache with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneCache with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneCache0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test C: Test passing out of bounds parameters to RMmCustomAPI::ReadViagHomeZoneCache
//-------------------------------------------------------------------------
RMmCustomAPI::TViagCacheRecordId KBadRecId[] =
{
{KViagHomeZoneCacheIdMin - 1, KViagHomeZoneCacheRecordIdMin },
{KViagHomeZoneCacheIdMax + 1, KViagHomeZoneCacheRecordIdMin },
{KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMin -1 },
{KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMax + 1}
};
for(TInt i = 0; i < sizeof(KBadRecId)/sizeof(KBadRecId[0]); i++)
{
TRequestStatus reqStatus;
RMmCustomAPI::TViagCacheRecordContent recContent;
customAPI.ReadViagHomeZoneCache(reqStatus,KBadRecId[i],recContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrArgument,reqStatus.Int());
}
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::ReadViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneCache0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::ReadViagHomeZoneCache
//-------------------------------------------------------------------------
RMmCustomAPI customAPI2;
RMmCustomAPI customAPI1;
const RMmCustomAPI::TViagCacheRecordContent& expectedContent2 =
iViagHomeZoneCache[0][0];
const RMmCustomAPI::TViagCacheRecordContent& expectedContent1 =
iViagHomeZoneCache[KViagHomeZoneCacheIdMax - KViagHomeZoneCacheIdMin][KViagHomeZoneCacheRecordIdMax - KViagHomeZoneCacheRecordIdMin];
RMmCustomAPI::TViagCacheRecordId recId2 = {KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMin };
RMmCustomAPI::TViagCacheRecordId recId1 = {KViagHomeZoneCacheIdMax, KViagHomeZoneCacheRecordIdMax };
RMmCustomAPI::TViagCacheRecordContent recContent2;
RMmCustomAPI::TViagCacheRecordContent recContent1;
TRequestStatus reqStatus2;
TRequestStatus reqStatus1;
//OpenPhoneAndCustomAPILC(customAPI1);
OpenPhoneL();
OpenCustomAPILC(customAPI1, iPhone, ETrue);
OpenCustomAPILC(customAPI2, phone2, EFalse);
// start reading from the 2-nd client.
customAPI2.ReadViagHomeZoneCache(reqStatus2,recId2,recContent2);
// start reading from the 1-st client
customAPI1.ReadViagHomeZoneCache(reqStatus1,recId1,recContent1);
// Complete the cashing
TBool expect = EFalse;
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMax; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
MockPrimeEReadViagHomeZoneCacheIPCL(c,r, ETrue, expect);
expect = ETrue;
}
}
// wait for results
User::WaitForRequest(reqStatus1);
User::WaitForRequest(reqStatus2);
// check 1-st client results
ASSERT_EQUALS(KErrNone,reqStatus1.Int());
ASSERT_EQUALS(expectedContent1.iLac, recContent1.iLac);
ASSERT_EQUALS(expectedContent1.iCellId, recContent1.iCellId);
// check 2-nd client results
ASSERT_EQUALS(KErrNone,reqStatus2.Int());
ASSERT_EQUALS(expectedContent2.iLac, recContent2.iLac);
ASSERT_EQUALS(expectedContent2.iCellId, recContent2.iCellId);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this); // customAPI2,phone2,telServer2,customAPI,this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRVHZC-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadViagHomeZoneCache with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadViagHomeZoneCache and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadViagHomeZoneCache0005L()
{
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 404902);
ASSERT_TRUE(EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::ReadViagHomeZoneCache
//-------------------------------------------------------------------------
TRequestStatus reqStatus;
RMmCustomAPI::TViagCacheRecordId recId = {KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMin };
RMmCustomAPI::TViagCacheRecordContent recContent;
// the request is never timed out
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 401805);
ASSERT_TRUE(EFalse);
customAPI.ReadViagHomeZoneCache(reqStatus,recId,recContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrTimedOut,reqStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::WriteViagHomeZoneCache
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::WriteViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneCache0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
RMmCustomAPI customAPI;
//********************************************************************************
//* To initiazlize the VIAG home zone cache properly RMmCustomAPI::OpenL should be
//* invoked _before_ EMmTsyBootNotifySimStatusReadyIPC is triggered.
//* That's why OpenPhoneAndCustomAPILC was implemented and is used here
//* instead of usual OpenPhoneL/OpenCustomAPILC sequence.
//********************************************************************************
OpenPhoneAndCustomAPILC(customAPI);
RBuf8 data;
data.CleanupClosePushL();
RMmCustomAPI::TViagCacheRecordId expRecId;
expRecId.iCacheId = KViagHomeZoneCacheIdMin;
expRecId.iRecordId = KViagHomeZoneCacheRecordIdMin;
RMmCustomAPI::TViagCacheRecordContent expContent;
expContent.iCellId = 3000;
expContent.iLac = 4000;
TMockLtsyData2<RMmCustomAPI::TViagCacheRecordId,
RMmCustomAPI::TViagCacheRecordContent> expData(expRecId,expContent);
TRequestStatus reqStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
expData.SerialiseL(data);
iMockLTSY.ExpectL(EWriteViagHomeZoneCacheIPC,data,KErrGeneral);
customAPI.WriteViagHomeZoneCache(reqStatus,expRecId,expContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrGeneral,reqStatus.Int())
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EWriteViagHomeZoneCacheIPC,data);
iMockLTSY.CompleteL(EWriteViagHomeZoneCacheIPC,KErrGeneral);
customAPI.WriteViagHomeZoneCache(reqStatus,expRecId,expContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrGeneral,reqStatus.Int())
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::WriteViagHomeZoneCache when result is not cached.
//-------------------------------------------------------------------------
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMax; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
expRecId.iCacheId = c;
expRecId.iRecordId = r;
expContent.iCellId = 3000 + c;
expContent.iLac = 4000 + r;
expData.Close();
expData.SerialiseL(data);
iMockLTSY.ExpectL(EWriteViagHomeZoneCacheIPC,data);
iMockLTSY.CompleteL(EWriteViagHomeZoneCacheIPC,KErrNone);
// write new cache content
customAPI.WriteViagHomeZoneCache(reqStatus,expRecId,expContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone,reqStatus.Int())
// read it to verify that it was written correctly
RMmCustomAPI::TViagCacheRecordContent newContent;
customAPI.ReadViagHomeZoneCache(reqStatus,expRecId,newContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrNone,reqStatus.Int())
ASSERT_EQUALS(expContent.iCellId,newContent.iCellId);
ASSERT_EQUALS(expContent.iLac,newContent.iLac);
}
}
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::WriteViagHomeZoneCache
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EWriteViagHomeZoneCacheIPC,KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this); // data, customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::WriteViagHomeZoneCache
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::WriteViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneCache0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
data.CleanupClosePushL();
RMmCustomAPI::TViagCacheRecordId expRecId;
expRecId.iCacheId = KViagHomeZoneCacheIdMin;
expRecId.iRecordId = KViagHomeZoneCacheRecordIdMin;
RMmCustomAPI::TViagCacheRecordContent expContent;
expContent.iCellId = 3000;
expContent.iLac = 4000;
TMockLtsyData2<RMmCustomAPI::TViagCacheRecordId,
RMmCustomAPI::TViagCacheRecordContent> expData(expRecId,expContent);
TRequestStatus reqStatus;
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::WriteViagHomeZoneCache
//-------------------------------------------------------------------------
expData.SerialiseL(data);
iMockLTSY.ExpectL(EWriteViagHomeZoneCacheIPC,data);
customAPI.WriteViagHomeZoneCache(reqStatus,expRecId,expContent);
customAPI.CancelAsyncRequest(EWriteViagHomeZoneCacheIPC);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrCancel,reqStatus.Int())
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3,this); // data, customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZC-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::WriteViagHomeZoneCache with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::WriteViagHomeZoneCache with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneCache0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test C: Test passing out of bounds parameters to
// RMmCustomAPI::WriteViagHomeZoneCache
//-------------------------------------------------------------------------
const RMmCustomAPI::TViagCacheRecordId KBadRecId[] =
{
{KViagHomeZoneCacheIdMin - 1, KViagHomeZoneCacheRecordIdMin },
{KViagHomeZoneCacheIdMax + 1, KViagHomeZoneCacheRecordIdMin },
{KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMin -1 },
{KViagHomeZoneCacheIdMin, KViagHomeZoneCacheRecordIdMax + 1}
};
const RMmCustomAPI::TViagCacheRecordContent KRecContent = {0,0};
for(TInt i = 0; i < sizeof(KBadRecId)/sizeof(KBadRecId[0]); i++)
{
TRequestStatus reqStatus;
customAPI.WriteViagHomeZoneCache(reqStatus,KBadRecId[i],KRecContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrArgument,reqStatus.Int());
}
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::WriteViagHomeZoneCache
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::WriteViagHomeZoneCache
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneCache0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
// Open 2-nd phone
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
// now open 1-st phone and two RMmCustomAPI-s
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenPhoneAndCustomAPILC(customAPI1);
OpenCustomAPILC(customAPI2, phone2, EFalse);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::WriteViagHomeZoneCache
//-------------------------------------------------------------------------
RMmCustomAPI::TViagCacheRecordId expRecId1;
expRecId1.iCacheId = KViagHomeZoneCacheIdMin;
expRecId1.iRecordId = KViagHomeZoneCacheRecordIdMin;
RMmCustomAPI::TViagCacheRecordId expRecId2;
expRecId2.iCacheId = KViagHomeZoneCacheIdMax;
expRecId2.iRecordId = KViagHomeZoneCacheRecordIdMax;
RMmCustomAPI::TViagCacheRecordContent expContent1;
expContent1.iCellId = 3001;
expContent1.iLac = 4001;
RMmCustomAPI::TViagCacheRecordContent expContent2;
expContent2.iCellId = 3002;
expContent2.iLac = 4002;
TRequestStatus reqStatus1;
TRequestStatus reqStatus2;
TMockLtsyData2<RMmCustomAPI::TViagCacheRecordId,
RMmCustomAPI::TViagCacheRecordContent> expData(expRecId1,expContent1);
RBuf8 data;
data.CleanupClosePushL();
// Only one EWriteViagHomeZoneCacheIPC request is passed to the Mock LTSY
expData.SerialiseL(data);
iMockLTSY.ExpectL(EWriteViagHomeZoneCacheIPC,data);
iMockLTSY.CompleteL(EWriteViagHomeZoneCacheIPC,KErrNone);
// Try to invoke two simultaneous EWriteViagHomeZoneCacheIPC requests.
// The 2-nd one should fail with KErrServerBusy.
customAPI1.WriteViagHomeZoneCache(reqStatus1,expRecId1,expContent1);
customAPI2.WriteViagHomeZoneCache(reqStatus2,expRecId2,expContent2);
User::WaitForRequest(reqStatus1);
User::WaitForRequest(reqStatus2);
ASSERT_EQUALS(KErrNone,reqStatus1.Int());
ASSERT_EQUALS(KErrServerBusy,reqStatus2.Int());
// verify that the record changed by the 1-st client is changed succesfully
RMmCustomAPI::TViagCacheRecordContent newContent;
customAPI1.ReadViagHomeZoneCache(reqStatus1,expRecId1,newContent);
User::WaitForRequest(reqStatus1);
ASSERT_EQUALS(KErrNone,reqStatus1.Int());
ASSERT_EQUALS(expContent1.iLac, newContent.iLac);
ASSERT_EQUALS(expContent1.iCellId, newContent.iCellId);
AssertMockLtsyStatusL();
// data, customAPI2, customAPI1, phone2, telServer2, this
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZC-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::WriteViagHomeZoneCache with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::WriteViagHomeZoneCache and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneCache0005L()
{
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 404902);
ASSERT_TRUE(EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI);
RBuf8 data;
data.CleanupClosePushL();
RMmCustomAPI::TViagCacheRecordId expRecId;
expRecId.iCacheId = KViagHomeZoneCacheIdMax;
expRecId.iRecordId = KViagHomeZoneCacheRecordIdMax;
RMmCustomAPI::TViagCacheRecordContent expContent;
expContent.iCellId = 6000;
expContent.iLac = 7000;
TMockLtsyData2<RMmCustomAPI::TViagCacheRecordId,
RMmCustomAPI::TViagCacheRecordContent> expData(expRecId,expContent);
TRequestStatus reqStatus;
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::WriteViagHomeZoneCache
//-------------------------------------------------------------------------
expData.SerialiseL(data);
iMockLTSY.ExpectL(EWriteViagHomeZoneCacheIPC,data);
customAPI.WriteViagHomeZoneCache(reqStatus,expRecId,expContent);
User::WaitForRequest(reqStatus);
ASSERT_EQUALS(KErrTimedOut,reqStatus.Int())
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this); // data, customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCCBL-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ClearCallBlackList
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ClearCallBlackList
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestClearCallBlackList0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomClearCallBlackListIPC, KErrNotSupported);
customAPI.ClearCallBlackList(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomClearCallBlackListIPC);
iMockLTSY.CompleteL( ECustomClearCallBlackListIPC, KErrGeneral);
customAPI.ClearCallBlackList(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::ClearCallBlackList when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomClearCallBlackListIPC);
iMockLTSY.CompleteL( ECustomClearCallBlackListIPC, KErrNone);
customAPI.ClearCallBlackList(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::ClearCallBlackList
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomClearCallBlackListIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCCBL-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ClearCallBlackList
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::ClearCallBlackList
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestClearCallBlackList0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::ClearCallBlackList
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomClearCallBlackListIPC);
iMockLTSY.CompleteL( ECustomClearCallBlackListIPC, KErrNone, 20);
customAPI.ClearCallBlackList(requestStatus);
customAPI.CancelAsyncRequest(ECustomClearCallBlackListIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCCBL-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ClearCallBlackList
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::ClearCallBlackList
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestClearCallBlackList0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::ClearCallBlackList
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomClearCallBlackListIPC, KErrNone);
iMockLTSY.CompleteL( ECustomClearCallBlackListIPC, KErrNone, 20);
customAPI.ClearCallBlackList(requestStatus);
customAPI2.ClearCallBlackList(requestStatus2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCCBL-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ClearCallBlackList with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ClearCallBlackList and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestClearCallBlackList0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
iMockLTSY.ExpectL( ECustomClearCallBlackListIPC);
customAPI.ClearCallBlackList(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAIN-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SsAdditionalInfoNotification
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SsAdditionalInfoNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSsAdditionalInfoNotification0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
_LIT8(KInfo, "Info");
RMmCustomAPI::TSsAdditionalInfo info;
RMmCustomAPI::TSsAdditionalInfo compInfo;
compInfo.iOperationCode = 0xFF;
compInfo.iAdditionalInfo.Copy(KInfo);
TPckg<RMmCustomAPI::TSsAdditionalInfo> pckg(compInfo);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SsAdditionalInfoNotification
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSsAdditionalInfoNotificationIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SsAdditionalInfoNotification when result is not cached.
//-------------------------------------------------------------------------
customAPI.SsAdditionalInfoNotification(requestStatus, info);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSsAdditionalInfoNotificationIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compInfo.iOperationCode == info.iOperationCode);
ASSERT_TRUE(0 == info.iAdditionalInfo.Compare(compInfo.iAdditionalInfo));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAIN-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SsAdditionalInfoNotification
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SsAdditionalInfoNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSsAdditionalInfoNotification0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
_LIT8(KInfo, "Info");
RMmCustomAPI::TSsAdditionalInfo info;
RMmCustomAPI::TSsAdditionalInfo compInfo;
compInfo.iOperationCode = 0xFF;
compInfo.iAdditionalInfo.Copy(KInfo);
TPckg<RMmCustomAPI::TSsAdditionalInfo> pckg(compInfo);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SsAdditionalInfoNotification
//-------------------------------------------------------------------------
customAPI.SsAdditionalInfoNotification(requestStatus, info);
customAPI.CancelAsyncRequest(ECustomSsAdditionalInfoNotificationIPC);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSsAdditionalInfoNotificationIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAIN-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SsAdditionalInfoNotification
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SsAdditionalInfoNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSsAdditionalInfoNotification0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
TRequestStatus mockLtsyStatus;
_LIT8(KInfo, "Info");
RMmCustomAPI::TSsAdditionalInfo info;
RMmCustomAPI::TSsAdditionalInfo info2;
RMmCustomAPI::TSsAdditionalInfo compInfo;
compInfo.iOperationCode = 0xFF;
compInfo.iAdditionalInfo.Copy(KInfo);
TPckg<RMmCustomAPI::TSsAdditionalInfo> pckg(compInfo);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::SsAdditionalInfoNotification
//-------------------------------------------------------------------------
customAPI1.SsAdditionalInfoNotification(requestStatus, info);
customAPI2.SsAdditionalInfoNotification(requestStatus2, info2);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSsAdditionalInfoNotificationIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_TRUE(compInfo.iOperationCode == info.iOperationCode);
ASSERT_TRUE(0 == info.iAdditionalInfo.Compare(compInfo.iAdditionalInfo));
ASSERT_TRUE(compInfo.iOperationCode == info2.iOperationCode);
ASSERT_TRUE(0 == info2.iAdditionalInfo.Compare(compInfo.iAdditionalInfo));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSRCN-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SsRequestCompleteNotification
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SsRequestCompleteNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSsRequestCompleteNotification0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TInt status;
const TInt compStatus = 0xFF;
TPckg<TInt> pckg(compStatus);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SsRequestCompleteNotification
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifySsRequestCompleteIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SsRequestCompleteNotification when result is not cached.
//-------------------------------------------------------------------------
customAPI.SsRequestCompleteNotification(requestStatus, status);
iMockLTSY.CompleteL(ECustomNotifySsRequestCompleteIPC, KErrNone, pckg);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(status, compStatus);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSRCN-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SsRequestCompleteNotification
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SsRequestCompleteNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSsRequestCompleteNotification0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
TInt status;
const TInt compStatus = 0xFF;
TPckg<TInt> pckg(compStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SsRequestCompleteNotification
//-------------------------------------------------------------------------
customAPI.SsRequestCompleteNotification(requestStatus, status);
customAPI.CancelAsyncRequest(ECustomNotifySsRequestCompleteIPC);
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifySsRequestCompleteIPC, KErrNone, pckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSRCN-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SsRequestCompleteNotification
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SsRequestCompleteNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSsRequestCompleteNotification0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI1;
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI1, iPhone);
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
TInt status;
TInt status2;
const TInt compStatus = 0xFF;
TPckg<TInt> pckg(compStatus);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::SsRequestCompleteNotification
//-------------------------------------------------------------------------
customAPI1.SsRequestCompleteNotification(requestStatus, status);
customAPI2.SsRequestCompleteNotification(requestStatus2, status2);
iMockLTSY.CompleteL(ECustomNotifySsRequestCompleteIPC, KErrNone, pckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(compStatus, status);
ASSERT_EQUALS(compStatus, status2);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCIB-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::IsBlocked
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::IsBlocked
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestIsBlocked0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TSecurityCodeType type(RMmCustomAPI::ESecurityCodePin1);
TBool result;
TUint8 codeId(KSecCodePin);
TMockLtsyData1 <TUint8> ltsyData(codeId);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomIsBlockedIPC, data, KErrNotSupported);
TInt ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrNotSupported, ret);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
const TBool compResult(ETrue);
TPckg<TBool> resPckg(compResult);
iMockLTSY.ExpectL( ECustomIsBlockedIPC, data);
iMockLTSY.CompleteL( ECustomIsBlockedIPC, KErrGeneral, resPckg);
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( ECustomIsBlockedIPC, data);
iMockLTSY.CompleteL( ECustomIsBlockedIPC, KErrNone, resPckg);
ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrNone, ret);
ASSERT_EQUALS(compResult, result);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::IsBlocked when result is not cached.
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityCodePin2;
codeId = KSecCodePin2;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomIsBlockedIPC, data);
iMockLTSY.CompleteL( ECustomIsBlockedIPC, KErrNone, resPckg);
ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrNone, ret);
ASSERT_EQUALS(compResult, result);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C3: Completion request of
// RMmCustomAPI::IsBlocked
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityCodePuk1;
ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrArgument, ret);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C4: Completion request of
// RMmCustomAPI::IsBlocked
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityUniversalPin;
ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrArgument, ret);
AssertMockLtsyStatusL();
//- making ICC3G ----------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TICCType iccType(EICCTypeSim3G);
TMockLtsyData1<TICCType> iccData(iccType);
data.Close();
iccData.SerialiseL(data);
iMockLTSY.CompleteL(EMmTsySimGetICCType, KErrNone, data);
iMockLTSY.ExpectL(EMmTsySecurityGetSimActivePinStateIPC);
iMockLTSY.CompleteL(EMmTsySecurityGetSimActivePinStateIPC, KErrNone);
// Wait for completion of iMockLTSY.NotifyTerminated
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C5: Successful completion request of
// RMmCustomAPI::IsBlocked when result is not cached.
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityUniversalPin;
codeId = KSecCodeUpin;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomIsBlockedIPC, data);
iMockLTSY.CompleteL( ECustomIsBlockedIPC, KErrNone, resPckg);
ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrNone, ret);
ASSERT_EQUALS(compResult, result);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C6: Successful completion request of
// RMmCustomAPI::IsBlocked when result is not cached.
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityCodePassPhrase;
codeId = KSecCodeSecurity;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomIsBlockedIPC, data);
iMockLTSY.CompleteL( ECustomIsBlockedIPC, KErrNone, resPckg);
ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrNone, ret);
ASSERT_EQUALS(compResult, result);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::IsBlocked
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomIsBlockedIPC, KErrNone, resPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCIB-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::IsBlocked with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::IsBlocked and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestIsBlocked0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TSecurityCodeType type(RMmCustomAPI::ESecurityCodePin1);
TBool result;
TUint8 codeId(KSecCodePin);
TMockLtsyData1 <TUint8> ltsyData(codeId);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomIsBlockedIPC, data);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 402401);
// Request ECustomIsBlockedIPC is not completed by timeout.
// to void next test blocking
ASSERT_TRUE(EFalse);
TInt ret = customAPI.IsBlocked(type, result);
ASSERT_EQUALS(KErrTimedOut, ret);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCSC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckSecurityCode
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckSecurityCode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckSecurityCode0001L()
{
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);
TUint8 codeId(KSecCodePin);
RMobilePhone::TMobilePassword secCode;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
TMockLtsyData2 <TUint8, RMobilePhone::TMobilePassword> ltsyData(codeId, secCode);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, 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( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrGeneral);
TBool flag(EFalse);
TMockLtsyData2 <TUint8, TBool> ltsyData2(codeId, flag);
ltsyData2.SerialiseL(data2);
// this is because HandleRequest(ECustomCheckSecurityCodeCancelIPC) is called when completing by error
iMockLTSY.ExpectL( ECustomCheckSecurityCodeCancelIPC, 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( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone);
customAPI.CheckSecurityCode(requestStatus, type);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::CheckSecurityCode when result is not cached.
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityCodePin2;
codeId = KSecCodePin2;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone);
customAPI.CheckSecurityCode(requestStatus, type);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C3: Successful completion request of
// RMmCustomAPI::CheckSecurityCode when result is not cached.
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityCodePuk1;
codeId = KSecCodePuk;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone);
customAPI.CheckSecurityCode(requestStatus, type);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C4: Successful completion request of
// RMmCustomAPI::CheckSecurityCode when result is not cached.
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityCodePuk2;
codeId = KSecCodePuk2;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone);
customAPI.CheckSecurityCode(requestStatus, type);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C5: Successful completion request of
// RMmCustomAPI::CheckSecurityCode when result is not cached.
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityCodePassPhrase;
codeId = KSecCodeSecurity;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone);
customAPI.CheckSecurityCode(requestStatus, type);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C6: Completion request of
// RMmCustomAPI::CheckSecurityCode when result type is ESecurityUniversalPin
//-------------------------------------------------------------------------
type = RMmCustomAPI::ESecurityUniversalPin;
customAPI.CheckSecurityCode(requestStatus, type);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::CheckSecurityCode
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCSC-0002
@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 CCTsyCustomIPCFU::TestCheckSecurityCode0002L()
{
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);
TUint8 codeId(KSecCodePin);
RMobilePhone::TMobilePassword secCode;
TMockLtsyData2 <TUint8, RMobilePhone::TMobilePassword> ltsyData(codeId, secCode);
ltsyData.SerialiseL(data);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test A: Cancelling of RMmCustomAPI::CheckSecurityCode
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
customAPI.CheckSecurityCode(requestStatus, type);
TBool flag(ETrue);
TMockLtsyData2 <TUint8, TBool> ltsyData2(codeId, flag);
ltsyData2.SerialiseL(data2);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeCancelIPC, data2);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrCancel);
customAPI.CancelAsyncRequest(ECustomCheckSecurityCodeIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
//-------------------------------------------------------------------------
// Test B: Cancelling of RMmCustomAPI::CheckSecurityCode
// Baseband returns the request successfully before handling cancel function.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone, 20);
customAPI.CheckSecurityCode(requestStatus, type);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeCancelIPC, data2);
customAPI.CancelAsyncRequest(ECustomCheckSecurityCodeIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCSC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::CheckSecurityCode
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::CheckSecurityCode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckSecurityCode0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TSecurityCodeType type(RMmCustomAPI::ESecurityCodePin1);
RMmCustomAPI::TSecurityCodeType type2(RMmCustomAPI::ESecurityCodePin1);
TUint8 codeId(KSecCodePin);
RMobilePhone::TMobilePassword secCode;
TMockLtsyData2 <TUint8, RMobilePhone::TMobilePassword> ltsyData(codeId, secCode);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::CheckSecurityCode
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
iMockLTSY.CompleteL( ECustomCheckSecurityCodeIPC, KErrNone,20);
customAPI.CheckSecurityCode(requestStatus, type);
customAPI2.CheckSecurityCode(requestStatus2, type2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCSC-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckSecurityCode with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckSecurityCode and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckSecurityCode0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::TSecurityCodeType type(RMmCustomAPI::ESecurityCodePin1);
TUint8 codeId(KSecCodePin);
RMobilePhone::TMobilePassword secCode;
TMockLtsyData2 <TUint8, RMobilePhone::TMobilePassword> ltsyData(codeId, secCode);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomCheckSecurityCodeIPC, data);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 402502);
// Request ECustomCheckSecurityCodeIPC is not completed by timeout.
// to avoid next test blocking
ASSERT_TRUE(EFalse);
customAPI.CheckSecurityCode(requestStatus, type);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGAP-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetActivePin
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetActivePin
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetActivePin0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMobilePhone::TMobilePhoneSecurityCode code;
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetActivePin when result is not cached.
//-------------------------------------------------------------------------
customAPI.GetActivePin(code);
ASSERT_EQUALS(RMobilePhone::ESecurityCodePin1, code);
AssertMockLtsyStatusL();
// now change the pin and get the changed value
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
const RMobilePhone::TMobilePhoneSecurityCode compCode(RMobilePhone::ESecurityCodePin2);
TPckg<RMobilePhone::TMobilePhoneSecurityCode> compPckg(compCode);
iMockLTSY.CompleteL(EMmTsySecurityGetSimActivePinStateIPC, KErrNone, compPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
customAPI.GetActivePin(code);
ASSERT_EQUALS(compCode, code);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGATD-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetAirTimeDuration
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetAirTimeDuration
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetAirTimeDuration0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TTimeIntervalSeconds sec;
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetAirTimeDuration when result is not cached.
//-------------------------------------------------------------------------
// check when there were no any calls on air
TInt ret = customAPI.GetAirTimeDuration(sec);
ASSERT_EQUALS(KErrNone, ret);
ASSERT_EQUALS(0, sec.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::GetAirTimeDuration when result is not cached.
//-------------------------------------------------------------------------
// check when there was a call on air
// first make the connected call
TName callName;
TInt callId(1);
RLine line;
RMobileCall call;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
OpenLineLC(line, iPhone, KMmTsyVoice1LineName);
CreateAndOpenIncomingCalLC(line, call, callName, KMmTsyVoice1LineName,
callId, RMobileCall::EStatusAnswering, mobileService);
RBuf8 completeData;
CleanupClosePushL(completeData);
RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusConnected;
TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
mockCallData2.SerialiseL(completeData);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// wait a little
User::After(2000000); //mcsec
ret = customAPI.GetAirTimeDuration(sec);
ASSERT_EQUALS(KErrNone, ret);
ASSERT_TRUE(0 < sec.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGNPN-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetNetworkProviderName
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetNetworkProviderName
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetNetworkProviderName0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TName name;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC, KErrNotSupported);
customAPI.GetNetworkProviderName(requestStatus, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC);
_LIT(KName, "ProviderName");
TName compName(KName);
TPckg<TName> compPckg(compName);
iMockLTSY.CompleteL( ECustomGetNetworkProviderNameIPC, KErrGeneral, compPckg);
customAPI.GetNetworkProviderName(requestStatus, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetNetworkProviderName when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC);
iMockLTSY.CompleteL( ECustomGetNetworkProviderNameIPC, KErrNone, compPckg);
customAPI.GetNetworkProviderName(requestStatus, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(0 == name.Compare(compName));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetNetworkProviderName
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetNetworkProviderNameIPC, KErrNone, compPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGNPN-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetNetworkProviderName
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetNetworkProviderName
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetNetworkProviderName0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TName name;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetNetworkProviderName
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC);
_LIT(KName, "ProviderName");
TName compName(KName);
TPckg<TName> compPckg(compName);
iMockLTSY.CompleteL( ECustomGetNetworkProviderNameIPC, KErrNone, compPckg, 20);
customAPI.GetNetworkProviderName(requestStatus, name);
customAPI.CancelAsyncRequest(ECustomGetNetworkProviderNameIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGNPN-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetNetworkProviderName with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetNetworkProviderName with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetNetworkProviderName0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TBuf<1> littleBuf;
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC);
_LIT(KName, "ProviderName");
TName compName(KName);
TPckg<TName> compPckg(compName);
iMockLTSY.CompleteL( ECustomGetNetworkProviderNameIPC, KErrNone, compPckg);
customAPI.GetNetworkProviderName(requestStatus, littleBuf);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGNPN-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetNetworkProviderName
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetNetworkProviderName
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetNetworkProviderName0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
TName name;
TName name2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetNetworkProviderName
//-------------------------------------------------------------------------
_LIT(KName, "ProviderName");
TName compName(KName);
TPckg<TName> compPckg(compName);
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC);
iMockLTSY.CompleteL( ECustomGetNetworkProviderNameIPC, KErrNone, compPckg, 20);
customAPI.GetNetworkProviderName(requestStatus, name);
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC);
_LIT(KName2, "ProviderName2");
TName compName2(KName2);
TPckg<TName> compPckg2(compName2);
iMockLTSY.CompleteL( ECustomGetNetworkProviderNameIPC, KErrNone, compPckg2);
customAPI2.GetNetworkProviderName(requestStatus2, name2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(0 == name.Compare(compName));
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_TRUE(0 == name2.Compare(compName2));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this); // customAPI2, customAPI, phone2, telServer2, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGNPN-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetNetworkProviderName with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetNetworkProviderName and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetNetworkProviderName0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TName name;
iMockLTSY.ExpectL( ECustomGetNetworkProviderNameIPC);
customAPI.GetNetworkProviderName(requestStatus, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCEN-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckEmergencyNumber
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckEmergencyNumber
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckEmergencyNumber0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
_LIT(KEmerNum, "IfThisIsEmer?");
TRequestStatus requestStatus;
RMmCustomAPI::TEmerNumberCheckMode mode;
mode.iCheckMode = RMmCustomAPI::EEmerNumberCheckAdvanced;
mode.iNumber.Copy(KEmerNum);
TBool result;
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TMockLtsyData1< RMmCustomAPI::TEmerNumberCheckMode > ltsyData(mode);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData, KErrNotSupported);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData);
_LIT(KNumber, "Number");
RMmCustomAPI::TMobileTelNumber telNumber(KNumber);
RMmCustomAPI::TMobileTelNumber* telNumberPtr(&telNumber);
TMockLtsyData1< RMmCustomAPI::TMobileTelNumber* > ltsyData2(telNumberPtr);
ltsyData2.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomCheckEmergencyNumberIPC, KErrGeneral, compData);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::CheckEmergencyNumber when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData);
iMockLTSY.CompleteL( ECustomCheckEmergencyNumberIPC, KErrNone, compData);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, mode.iNumber.Compare(telNumber));
ASSERT_EQUALS(1, result);
//-------------------------------------------------------------------------
// TEST C1: mode.iCheckMode = RMmCustomAPI::EEmerNumberCheckNormal;
//-------------------------------------------------------------------------
mode.iNumber.Copy(KEmerNum);
mode.iCheckMode = RMmCustomAPI::EEmerNumberCheckNormal;
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData);
iMockLTSY.CompleteL( ECustomCheckEmergencyNumberIPC, KErrNone, compData);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, mode.iNumber.Compare(telNumber));
ASSERT_EQUALS(1, result);
//-------------------------------------------------------------------------
// TEST C2: now check with telNumberPtr = NULL
//-------------------------------------------------------------------------
telNumberPtr = NULL;
compData.Close();
ltsyData2.SerialiseL(compData);
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData);
iMockLTSY.CompleteL( ECustomCheckEmergencyNumberIPC, KErrNone, compData);
mode.iNumber.Copy(KEmerNum);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, mode.iNumber.Compare(KEmerNum));
ASSERT_TRUE(EFalse == result);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::CheckEmergencyNumber
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomCheckEmergencyNumberIPC, KErrNone, compData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// check a branch with iISVDialNumberCheck
TName callName;
TInt callId(1);
RLine line;
RMobileCall call;
RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
OpenLineLC(line, iPhone, KMmTsyVoice1LineName);
CreateAndOpenIncomingCalLC(line, call, callName, KMmTsyVoice1LineName,
callId, RMobileCall::EStatusIdle, mobileService);
_LIT(KPhoneNumber, "135468456456");
RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams;
callParams.iIdRestrict = RMobileCall::ESendMyId;
callParams.iAutoRedial = ETrue;
mode.iCheckMode = RMmCustomAPI::EEmerNumberCheckNormal;
mode.iNumber.Copy(KPhoneNumber);
expectData.Close();
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData, KErrNotSupported);
TPckg<RMobileCall::TEtel3rdPartyMobileCallParamsV1> pckgCallParams(callParams);
call.DialISV(requestStatus, pckgCallParams, KPhoneNumber);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrServerBusy, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCEN-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::CheckEmergencyNumber
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::CheckEmergencyNumber
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckEmergencyNumber0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
_LIT(KEmerNum, "IfThisIsEmer?");
TRequestStatus requestStatus;
TBool result;
RMmCustomAPI::TEmerNumberCheckMode mode;
mode.iCheckMode = RMmCustomAPI::EEmerNumberCheckAdvanced;
mode.iNumber.Copy(KEmerNum);
TMockLtsyData1< RMmCustomAPI::TEmerNumberCheckMode > ltsyData(mode);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::CheckEmergencyNumber
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
customAPI.CancelAsyncRequest(ECustomCheckEmergencyNumberIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
_LIT(KNumber, "Number");
RMmCustomAPI::TMobileTelNumber telNumber(KNumber);
RMmCustomAPI::TMobileTelNumber* telNumberPtr(&telNumber);
TMockLtsyData1< RMmCustomAPI::TMobileTelNumber* > ltsyData2(telNumberPtr);
ltsyData2.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomCheckEmergencyNumberIPC, KErrNone, compData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCEN-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::CheckEmergencyNumber
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::CheckEmergencyNumber
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckEmergencyNumber0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
_LIT(KEmerNum, "IfThisIsEmer?");
TRequestStatus requestStatus;
TBool result;
RMmCustomAPI::TEmerNumberCheckMode mode;
mode.iCheckMode = RMmCustomAPI::EEmerNumberCheckAdvanced;
mode.iNumber.Copy(KEmerNum);
TMockLtsyData1< RMmCustomAPI::TEmerNumberCheckMode > ltsyData(mode);
ltsyData.SerialiseL(expectData);
TRequestStatus requestStatus2;
TBool result2;
RMmCustomAPI::TEmerNumberCheckMode mode2;
mode2.iCheckMode = RMmCustomAPI::EEmerNumberCheckAdvanced;
mode2.iNumber.Copy(KEmerNum);
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData);
_LIT(KNumber, "Number");
RMmCustomAPI::TMobileTelNumber telNumber(KNumber);
RMmCustomAPI::TMobileTelNumber* telNumberPtr(&telNumber);
TMockLtsyData1< RMmCustomAPI::TMobileTelNumber* > ltsyData2(telNumberPtr);
ltsyData2.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomCheckEmergencyNumberIPC, KErrNone, compData, 10);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
customAPI2.CheckEmergencyNumber(requestStatus2, mode2, result2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCEN-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckEmergencyNumber with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckEmergencyNumber and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckEmergencyNumber0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 expectData;
CleanupClosePushL(expectData);
_LIT(KEmerNum, "IfThisIsEmer?");
TRequestStatus requestStatus;
TBool result;
RMmCustomAPI::TEmerNumberCheckMode mode;
mode.iCheckMode = RMmCustomAPI::EEmerNumberCheckAdvanced;
mode.iNumber.Copy(KEmerNum);
TMockLtsyData1< RMmCustomAPI::TEmerNumberCheckMode > ltsyData(mode);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomCheckEmergencyNumberIPC, expectData);
customAPI.CheckEmergencyNumber(requestStatus, mode, result);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNPCR-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyPndCacheReady
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyPndCacheReady
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyPndCacheReady0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TName name;
RMobilePhoneBookStore bookStore;
TName pbName(KETelIccAdnPhoneBook);
//-------------------------------------------------------------------------
// TEST C: Successful completion request of RMmCustomAPI::NotifyPndCacheReady
//-------------------------------------------------------------------------
customAPI.NotifyPndCacheReady(requestStatus, name);
OpenPhoneBookStoreL(bookStore, pbName, iPhone);
CleanupClosePushL(bookStore);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, name.Compare(pbName));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNPCR-0001b
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyPndCacheReady when caching has been originated from SIM.
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyPndCacheReady
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyPndCacheReady0001bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TName name;
TName pbName(KETelIccAdnPhoneBook);
//-------------------------------------------------------------------------
// TEST A: Successful completion request of RMmCustomAPI::NotifyPndCacheReady
// when caching has been originated from SIM.
//-------------------------------------------------------------------------
customAPI.NotifyPndCacheReady(requestStatus, name);
TInt simError = KErrNone;
RMobilePhoneBookStore bookStore;
OpenPhoneBookStoreWithSIMRefreshL(bookStore, pbName, iPhone, simError);
CleanupClosePushL(bookStore);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, name.Compare(pbName));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
//----------------------------------------------------------
// Telephony server has to be opened to test this
// scenario otherwise the below condition is not
// easy to test.
//----------------------------------------------------------
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, iPhone);
TRequestStatus requestStatus2;
TName name2;
//-------------------------------------------------------------------------
// TEST B: Unsuccessful completion request of RMmCustomAPI::NotifyPndCacheReady
// when caching has been originated from SIM.
//-------------------------------------------------------------------------
customAPI2.NotifyPndCacheReady(requestStatus2, name2);
RMobilePhoneBookStore bookStore2;
simError = KErrGeneral;
OpenPhoneBookStoreWithSIMRefreshL(bookStore2, pbName, iPhone, simError);
CleanupClosePushL(bookStore2);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrGeneral, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNPCR-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyPndCacheReady
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyPndCacheReady
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyPndCacheReady0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TName name;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyPndCacheReady
//-------------------------------------------------------------------------
customAPI.NotifyPndCacheReady(requestStatus, name);
_LIT(KName, "Name");
TName compName(KName);
TPckg<TName> compNamePckg(compName);
iMockLTSY.CompleteL(ECustomNotifyPndCacheReadyIPC, KErrNone, compNamePckg, 20);
customAPI.CancelAsyncRequest(ECustomNotifyPndCacheReadyIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNPCR-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyPndCacheReady with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyPndCacheReady with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyPndCacheReady0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TName name;
RBuf8 data;
CleanupClosePushL(data);
RBuf8 data2;
CleanupClosePushL(data2);
RBuf8 data3;
CleanupClosePushL(data3);
RMobilePhoneBookStore bookStore;
TName pbName(KETelIccAdnPhoneBook);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TMockLtsyPhoneBookData0 storeInitData(pbName);
storeInitData.SerialiseL(data);
CStorageInfoData storageData;
SetStorageInfoData(storageData);
TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(pbName, storageData);
retStoreInitC.SerialiseL(data2);
//EMmTsyPhoneBookStoreCacheIPC
CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
CleanupStack::PushL(cache);
TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(pbName, cache);
storeCacheData.SerialiseL(data3);
//-------------------------------------------------------------------------
// TEST 1: completion by error value from CMmPhoneBookStoreTsy::CompletePBStoreInitializationL()
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);
iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrGeneral, data2);
customAPI.NotifyPndCacheReady(requestStatus, name);
TInt ret = bookStore.Open(iPhone, pbName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(bookStore);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
ASSERT_EQUALS(0, name.Compare(pbName));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(1);
//-------------------------------------------------------------------------
// TEST 2: completion by error value from CMmPhoneBookStoreTsy::CompleteCachingL()
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);
iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2);
iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, data);
iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrGeneral, data3);
customAPI.NotifyPndCacheReady(requestStatus, name);
ret = bookStore.Open(iPhone, pbName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(bookStore);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
ASSERT_EQUALS(0, name.Compare(pbName));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNPCR-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyPndCacheReady
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyPndCacheReady
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyPndCacheReady0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
TName name;
TName name2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyPndCacheReady
//-------------------------------------------------------------------------
customAPI.NotifyPndCacheReady(requestStatus, name);
customAPI2.NotifyPndCacheReady(requestStatus2, name2);
RMobilePhoneBookStore bookStore;
TName pbName(KETelIccAdnPhoneBook);
OpenPhoneBookStoreL(bookStore, pbName, iPhone);
CleanupClosePushL(bookStore);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, name.Compare(pbName));
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(0, name2.Compare(pbName));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGPCS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetPndCacheStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetPndCacheStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetPndCacheStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TPndCacheStatus status;
// TEST C: Successful completion request of
// RMmCustomAPI::GetPndCacheStatus when result is not cached.
// Check KETelIccAdnPhoneBook
TName name;
name.Copy(KETelIccAdnPhoneBook);
customAPI.GetPndCacheStatus(requestStatus, status, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::ECacheNotReady == status);
AssertMockLtsyStatusL();
// TEST C2: Successful completion request of
// RMmCustomAPI::GetPndCacheStatus when result is not cached.
// Check KETelIccFdnPhoneBook
name.Copy(KETelIccFdnPhoneBook);
customAPI.GetPndCacheStatus(requestStatus, status, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::ECacheNotReady == status);
AssertMockLtsyStatusL();
// TEST C3: Successful completion request of
// RMmCustomAPI::GetPndCacheStatus when result is not cached.
// Check KETelIccBdnPhoneBook
name.Copy(KETelIccBdnPhoneBook );
customAPI.GetPndCacheStatus(requestStatus, status, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::ECacheNotUsed == status);
AssertMockLtsyStatusL();
// TEST C4: Successful completion request of
// RMmCustomAPI::GetPndCacheStatus when result is not cached.
// Check KETelIccSdnPhoneBook
name.Copy(KETelIccSdnPhoneBook );
customAPI.GetPndCacheStatus(requestStatus, status, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::ECacheNotUsed == status);
AssertMockLtsyStatusL();
// TEST C5: Successful completion request of
// RMmCustomAPI::GetPndCacheStatus when result is not cached.
// Check KETelIccVoiceMailBox
name.Copy(KETelIccVoiceMailBox );
customAPI.GetPndCacheStatus(requestStatus, status, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::ECacheNotUsed == status);
AssertMockLtsyStatusL();
// TEST C6: Successful completion request of
// RMmCustomAPI::GetPndCacheStatus.
// Get cache ready.
name.Copy(KETelIccAdnPhoneBook );
RMobilePhoneBookStore bookStore;
OpenPhoneBookStoreL(bookStore, name, iPhone);
CleanupClosePushL(bookStore);
customAPI.GetPndCacheStatus(requestStatus, status, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::ECacheReady == status);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGPCS-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetPndCacheStatus with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetPndCacheStatus with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetPndCacheStatus0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TPndCacheStatus status;
// Check non-existing phoneBookStore
_LIT(KBadName, "BadName");
TName name;
name.Copy(KBadName);
customAPI.GetPndCacheStatus(requestStatus, status, name);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGON-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetOperatorName
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetOperatorName
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetOperatorName0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TOperatorNameInfo info;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetOperatorNameIPC, KErrNotSupported);
customAPI.GetOperatorName(requestStatus, info);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetOperatorNameIPC);
_LIT(KName, "OperName");
RMmCustomAPI::TOperatorNameInfo compInfo;
compInfo.iType = RMmCustomAPI::EOperatorNameProgrammableLatin;
compInfo.iName.Copy(KName);
TPckg<RMmCustomAPI::TOperatorNameInfo> compInfoPckg(compInfo);
iMockLTSY.CompleteL( ECustomGetOperatorNameIPC, KErrGeneral, compInfoPckg);
customAPI.GetOperatorName(requestStatus, info);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetOperatorName when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetOperatorNameIPC);
iMockLTSY.CompleteL( ECustomGetOperatorNameIPC, KErrNone, compInfoPckg);
customAPI.GetOperatorName(requestStatus, info);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compInfo.iType == info.iType);
ASSERT_TRUE(0 == info.iName.Compare(compInfo.iName));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetOperatorName
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetOperatorNameIPC, KErrNone, compInfoPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGON-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetOperatorName
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetOperatorName
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetOperatorName0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TOperatorNameInfo info;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetOperatorName
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetOperatorNameIPC);
_LIT(KName, "OperName");
RMmCustomAPI::TOperatorNameInfo compInfo;
compInfo.iType = RMmCustomAPI::EOperatorNameProgrammableLatin;
compInfo.iName.Copy(KName);
TPckg<RMmCustomAPI::TOperatorNameInfo> compInfoPckg(compInfo);
iMockLTSY.CompleteL( ECustomGetOperatorNameIPC, KErrNone, compInfoPckg, 20);
customAPI.GetOperatorName(requestStatus, info);
customAPI.CancelAsyncRequest(ECustomGetOperatorNameIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGON-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetOperatorName
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetOperatorName
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetOperatorName0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TOperatorNameInfo info;
RMmCustomAPI::TOperatorNameInfo info2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetOperatorName
//-------------------------------------------------------------------------
_LIT(KName, "OperName");
RMmCustomAPI::TOperatorNameInfo compInfo;
compInfo.iType = RMmCustomAPI::EOperatorNameProgrammableLatin;
compInfo.iName.Copy(KName);
TPckg<RMmCustomAPI::TOperatorNameInfo> compInfoPckg(compInfo);
iMockLTSY.ExpectL( ECustomGetOperatorNameIPC, KErrNone);
iMockLTSY.CompleteL( ECustomGetOperatorNameIPC, KErrNone, compInfoPckg, 20);
customAPI.GetOperatorName(requestStatus, info);
_LIT(KName2, "OperName2");
RMmCustomAPI::TOperatorNameInfo compInfo2;
compInfo2.iType = RMmCustomAPI::EOperatorNameNitzShort;
compInfo2.iName.Copy(KName2);
TPckg<RMmCustomAPI::TOperatorNameInfo> compInfoPckg2(compInfo2);
iMockLTSY.ExpectL( ECustomGetOperatorNameIPC, KErrNone);
iMockLTSY.CompleteL( ECustomGetOperatorNameIPC, KErrNone, compInfoPckg2);
customAPI2.GetOperatorName(requestStatus2, info2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compInfo.iType == info.iType);
ASSERT_TRUE(0 == info.iName.Compare(compInfo.iName));
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_TRUE(compInfo2.iType == info2.iType);
ASSERT_TRUE(0 == info2.iName.Compare(compInfo2.iName));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGON-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetOperatorName with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetOperatorName and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetOperatorName0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TOperatorNameInfo info;
iMockLTSY.ExpectL( ECustomGetOperatorNameIPC);
customAPI.GetOperatorName(requestStatus, info);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGPOL-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetProgrammableOperatorLogo
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetProgrammableOperatorLogo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetProgrammableOperatorLogo0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI::TOperatorId oper;
RMmCustomAPI::TOperatorLogo logo;
TBuf8<128> buf;
logo.iOperatorLogo = &buf;
oper.iMcc = 0;
oper.iMnc = 0;
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TRequestStatus requestStatus;
TMockLtsyData1< RMmCustomAPI::TOperatorId > ltsyData(oper);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetProgrammableOperatorLogoIPC, expectData, KErrNotSupported);
customAPI.GetProgrammableOperatorLogo(requestStatus, oper, logo);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetProgrammableOperatorLogoIPC, expectData);
_LIT8(KBuf, "BufBufBufBufBuf");
TBuf8<KSerialNumberLength> compBuf(KBuf);
RMmCustomAPI::TOperatorId operComp;
RMmCustomAPI::TOperatorLogo logoComp;
operComp.iMcc = 1;
operComp.iMnc = 1;
logoComp.iLogoInfo.iLogoWidth = 2;
logoComp.iLogoInfo.iLogoHeight = 2;
logoComp.iLogoInfo.iCompression = 2;
logoComp.iLogoInfo.iDepth = RMmCustomAPI::EBitPerPixel1;
logoComp.iOperatorLogo = &compBuf;
TMockLtsyData2< RMmCustomAPI::TOperatorId, RMmCustomAPI::TOperatorLogo> ltsyData2(operComp, logoComp);
ltsyData2.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomGetProgrammableOperatorLogoIPC, KErrGeneral, compData);
customAPI.GetProgrammableOperatorLogo(requestStatus, oper, logo);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetProgrammableOperatorLogo when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetProgrammableOperatorLogoIPC, expectData);
iMockLTSY.CompleteL( ECustomGetProgrammableOperatorLogoIPC, KErrNone, compData);
customAPI.GetProgrammableOperatorLogo(requestStatus, oper, logo);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(operComp.iMcc == oper.iMcc);
ASSERT_TRUE(operComp.iMnc == oper.iMnc);
ASSERT_TRUE(logoComp.iLogoInfo.iLogoWidth == logo.iLogoInfo.iLogoWidth);
ASSERT_TRUE(logoComp.iLogoInfo.iLogoHeight == logo.iLogoInfo.iLogoHeight);
ASSERT_TRUE(logoComp.iLogoInfo.iCompression == logo.iLogoInfo.iCompression);
ASSERT_TRUE(logoComp.iLogoInfo.iDepth == logo.iLogoInfo.iDepth);
ASSERT_TRUE(0 == logoComp.iOperatorLogo->Compare(*logo.iOperatorLogo));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetProgrammableOperatorLogo
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetProgrammableOperatorLogoIPC, KErrNone, compData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGPOL-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetProgrammableOperatorLogo
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetProgrammableOperatorLogo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetProgrammableOperatorLogo0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
RMmCustomAPI::TOperatorId oper;
RMmCustomAPI::TOperatorLogo logo;
oper.iMcc = 0;
oper.iMnc = 0;
TMockLtsyData1< RMmCustomAPI::TOperatorId > ltsyData(oper);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetProgrammableOperatorLogo
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetProgrammableOperatorLogoIPC, expectData);
customAPI.GetProgrammableOperatorLogo(requestStatus, oper, logo);
customAPI.CancelAsyncRequest(ECustomGetProgrammableOperatorLogoIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
RMmCustomAPI::TOperatorId operComp;
RMmCustomAPI::TOperatorLogo logoComp;
_LIT8(KBuf, "BufBufBufBufBuf");
TBuf8<KSerialNumberLength> compBuf(KBuf);
logoComp.iOperatorLogo = &compBuf;
TMockLtsyData2< RMmCustomAPI::TOperatorId, RMmCustomAPI::TOperatorLogo> ltsyData2(operComp, logoComp);
ltsyData2.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomGetProgrammableOperatorLogoIPC, KErrNone, compData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGPOL-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetProgrammableOperatorLogo with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetProgrammableOperatorLogo with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetProgrammableOperatorLogo0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TOperatorId oper;
RMmCustomAPI::TOperatorLogo logo;
oper.iMcc = 0;
oper.iMnc = 0;
TBuf8<1> littleBuf;
logo.iOperatorLogo = &littleBuf;
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TMockLtsyData1< RMmCustomAPI::TOperatorId > ltsyData(oper);
ltsyData.SerialiseL(expectData);
RMmCustomAPI::TOperatorId operComp;
RMmCustomAPI::TOperatorLogo logoComp;
_LIT8(KBuf, "BufBufBufBufBuf");
TBuf8<KSerialNumberLength> compBuf(KBuf);
operComp.iMcc = 1;
operComp.iMnc = 1;
logoComp.iLogoInfo.iLogoWidth = 2;
logoComp.iLogoInfo.iLogoHeight = 2;
logoComp.iLogoInfo.iCompression = 2;
logoComp.iLogoInfo.iDepth = RMmCustomAPI::EBitPerPixel1;
logoComp.iOperatorLogo = &compBuf;
TMockLtsyData2< RMmCustomAPI::TOperatorId, RMmCustomAPI::TOperatorLogo> ltsyData2(operComp, logoComp);
ltsyData2.SerialiseL(compData);
iMockLTSY.ExpectL( ECustomGetProgrammableOperatorLogoIPC, expectData);
iMockLTSY.CompleteL( ECustomGetProgrammableOperatorLogoIPC, KErrNone, compData);
customAPI.GetProgrammableOperatorLogo(requestStatus, oper, logo);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTooBig, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGPOL-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetProgrammableOperatorLogo
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetProgrammableOperatorLogo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetProgrammableOperatorLogo0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TOperatorId oper;
RMmCustomAPI::TOperatorLogo logo;
oper.iMcc = 0;
oper.iMnc = 0;
RMmCustomAPI::TOperatorId oper2;
RMmCustomAPI::TOperatorLogo logo2;
oper2.iMcc = 0;
oper2.iMnc = 0;
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TMockLtsyData1< RMmCustomAPI::TOperatorId > ltsyData(oper);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomGetProgrammableOperatorLogoIPC, expectData);
RMmCustomAPI::TOperatorId operComp;
RMmCustomAPI::TOperatorLogo logoComp;
_LIT8(KBuf, "BufBufBufBufBuf");
TBuf8<KSerialNumberLength> compBuf(KBuf);
operComp.iMcc = 1;
operComp.iMnc = 1;
logoComp.iLogoInfo.iLogoWidth = 2;
logoComp.iLogoInfo.iLogoHeight = 2;
logoComp.iLogoInfo.iCompression = 2;
logoComp.iLogoInfo.iDepth = RMmCustomAPI::EBitPerPixel1;
logoComp.iOperatorLogo = &compBuf;
TMockLtsyData2< RMmCustomAPI::TOperatorId, RMmCustomAPI::TOperatorLogo> ltsyData2(operComp, logoComp);
ltsyData2.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomGetProgrammableOperatorLogoIPC, KErrNone, compData, 20);
customAPI.GetProgrammableOperatorLogo(requestStatus, oper, logo);
customAPI2.GetProgrammableOperatorLogo(requestStatus2, oper2, logo2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGPOL-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetProgrammableOperatorLogo with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetProgrammableOperatorLogo and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetProgrammableOperatorLogo0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TOperatorId oper;
RMmCustomAPI::TOperatorLogo logo;
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMmCustomAPI::TOperatorId > ltsyData(oper);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomGetProgrammableOperatorLogoIPC, expectData);
customAPI.GetProgrammableOperatorLogo(requestStatus, oper, logo);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNPOLC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyProgrammableOperatorLogoChange
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyProgrammableOperatorLogoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyProgrammableOperatorLogoChange0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TOperatorId operatorId;
operatorId.iMcc = 0;
operatorId.iMnc = 0;
// tests for RMmCustomAPI::NotifyProgrammableOperatorLogoChange should be written when ECustomNotifyProgrammableOperatorLogoChangeIPC
// would be proccessed.
customAPI.NotifyProgrammableOperatorLogoChange( requestStatus, operatorId);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNSNE-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifySsNetworkEvent
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifySsNetworkEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifySsNetworkEvent0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::TSsTypeAndMode ssTypeAndMode;
RMmCustomAPI::TSsInfo ssInfo;
RMmCustomAPI::TSsTypeAndMode ssTypeAndModeComp;
RMmCustomAPI::TSsInfo ssInfoComp;
// fill with random data
_LIT(KRemote, "Remote");
ssTypeAndModeComp.iSsType = RMmCustomAPI::ESsForwNoReply;
ssTypeAndModeComp.iSsMode = RMmCustomAPI::ESsModeActive;
ssInfoComp.iForwMode = RMmCustomAPI::ESsOutCallForwToC;
ssInfoComp.iCallWait = ETrue;
ssInfoComp.iCallHold = RMmCustomAPI::ESsHoldResume;
ssInfoComp.iConfInd = ETrue;
ssInfoComp.iCugIndex = 15;
ssInfoComp.iClirSuppReject = EFalse;
ssInfoComp.iEctCallState = RMmCustomAPI::ESsEctAlerting;
ssInfoComp.iChoice = RMmCustomAPI::ESsPresRestrictedAddress;
ssInfoComp.iRemoteAddress.Copy(KRemote);
TMockLtsyData2< RMmCustomAPI::TSsTypeAndMode, RMmCustomAPI::TSsInfo >
ltsyData(ssTypeAndModeComp, ssInfoComp);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifySsNetworkEvent
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifySsNetworkEventIPC, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
customAPI.NotifySsNetworkEvent(requestStatus, ssTypeAndMode, ssInfo);
iMockLTSY.CompleteL(ECustomNotifySsNetworkEventIPC, KErrGeneral, data);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifySsNetworkEvent when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifySsNetworkEvent(requestStatus, ssTypeAndMode, ssInfo);
iMockLTSY.CompleteL(ECustomNotifySsNetworkEventIPC, KErrNone, data);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(ssTypeAndModeComp.iSsType == ssTypeAndMode.iSsType);
ASSERT_TRUE(ssTypeAndModeComp.iSsMode == ssTypeAndMode.iSsMode);
ASSERT_TRUE(ssInfoComp.iForwMode == ssInfo.iForwMode);
ASSERT_TRUE(ssInfoComp.iCallWait == ssInfo.iCallWait);
ASSERT_TRUE(ssInfoComp.iCallHold == ssInfo.iCallHold);
ASSERT_TRUE(ssInfoComp.iConfInd == ssInfo.iConfInd);
ASSERT_TRUE(ssInfoComp.iCugIndex == ssInfo.iCugIndex);
ASSERT_TRUE(ssInfoComp.iClirSuppReject == ssInfo.iClirSuppReject);
ASSERT_TRUE(ssInfoComp.iEctCallState == ssInfo.iEctCallState);
ASSERT_TRUE(ssInfoComp.iChoice == ssInfo.iChoice);
ASSERT_TRUE(0 == ssInfo.iRemoteAddress.Compare(ssInfoComp.iRemoteAddress));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNSNE-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifySsNetworkEvent
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifySsNetworkEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifySsNetworkEvent0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::TSsTypeAndMode ssTypeAndMode;
RMmCustomAPI::TSsInfo ssInfo;
RMmCustomAPI::TSsTypeAndMode ssTypeAndModeComp;
RMmCustomAPI::TSsInfo ssInfoComp;
TMockLtsyData2< RMmCustomAPI::TSsTypeAndMode, RMmCustomAPI::TSsInfo >
ltsyData(ssTypeAndModeComp, ssInfoComp);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifySsNetworkEvent
//-------------------------------------------------------------------------
customAPI.NotifySsNetworkEvent(requestStatus, ssTypeAndMode, ssInfo);
customAPI.CancelAsyncRequest(ECustomNotifySsNetworkEventIPC);
iMockLTSY.CompleteL(ECustomNotifySsNetworkEventIPC, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNSNE-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifySsNetworkEvent
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifySsNetworkEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifySsNetworkEvent0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TSsTypeAndMode ssTypeAndMode;
RMmCustomAPI::TSsInfo ssInfo;
RMmCustomAPI::TSsTypeAndMode ssTypeAndMode2;
RMmCustomAPI::TSsInfo ssInfo2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifySsNetworkEvent
//-------------------------------------------------------------------------
customAPI.NotifySsNetworkEvent(requestStatus, ssTypeAndMode, ssInfo);
customAPI2.NotifySsNetworkEvent(requestStatus2, ssTypeAndMode2, ssInfo2);
// fill with random data
_LIT(KRemote, "Remote");
RMmCustomAPI::TSsTypeAndMode ssTypeAndModeComp;
RMmCustomAPI::TSsInfo ssInfoComp;
ssTypeAndModeComp.iSsType = RMmCustomAPI::ESsForwNoReply;
ssTypeAndModeComp.iSsMode = RMmCustomAPI::ESsModeActive;
ssInfoComp.iForwMode = RMmCustomAPI::ESsOutCallForwToC;
ssInfoComp.iCallWait = ETrue;
ssInfoComp.iCallHold = RMmCustomAPI::ESsHoldResume;
ssInfoComp.iConfInd = ETrue;
ssInfoComp.iCugIndex = 15;
ssInfoComp.iClirSuppReject = EFalse;
ssInfoComp.iEctCallState = RMmCustomAPI::ESsEctAlerting;
ssInfoComp.iChoice = RMmCustomAPI::ESsPresRestrictedAddress;
ssInfoComp.iRemoteAddress.Copy(KRemote);
TMockLtsyData2< RMmCustomAPI::TSsTypeAndMode, RMmCustomAPI::TSsInfo >
ltsyData(ssTypeAndModeComp, ssInfoComp);
ltsyData.SerialiseL(data);
iMockLTSY.CompleteL(ECustomNotifySsNetworkEventIPC, KErrNone, data);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(ssTypeAndModeComp.iSsType == ssTypeAndMode.iSsType);
ASSERT_TRUE(ssTypeAndModeComp.iSsMode == ssTypeAndMode.iSsMode);
ASSERT_TRUE(ssInfoComp.iForwMode == ssInfo.iForwMode);
ASSERT_TRUE(ssInfoComp.iCallWait == ssInfo.iCallWait);
ASSERT_TRUE(ssInfoComp.iCallHold == ssInfo.iCallHold);
ASSERT_TRUE(ssInfoComp.iConfInd == ssInfo.iConfInd);
ASSERT_TRUE(ssInfoComp.iCugIndex == ssInfo.iCugIndex);
ASSERT_TRUE(ssInfoComp.iClirSuppReject == ssInfo.iClirSuppReject);
ASSERT_TRUE(ssInfoComp.iEctCallState == ssInfo.iEctCallState);
ASSERT_TRUE(ssInfoComp.iChoice == ssInfo.iChoice);
ASSERT_TRUE(0 == ssInfo.iRemoteAddress.Compare(ssInfoComp.iRemoteAddress));
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_TRUE(ssTypeAndModeComp.iSsType == ssTypeAndMode2.iSsType);
ASSERT_TRUE(ssTypeAndModeComp.iSsMode == ssTypeAndMode2.iSsMode);
ASSERT_TRUE(ssInfoComp.iForwMode == ssInfo2.iForwMode);
ASSERT_TRUE(ssInfoComp.iCallWait == ssInfo2.iCallWait);
ASSERT_TRUE(ssInfoComp.iCallHold == ssInfo2.iCallHold);
ASSERT_TRUE(ssInfoComp.iConfInd == ssInfo2.iConfInd);
ASSERT_TRUE(ssInfoComp.iCugIndex == ssInfo2.iCugIndex);
ASSERT_TRUE(ssInfoComp.iClirSuppReject == ssInfo2.iClirSuppReject);
ASSERT_TRUE(ssInfoComp.iEctCallState == ssInfo2.iEctCallState);
ASSERT_TRUE(ssInfoComp.iChoice == ssInfo2.iChoice);
ASSERT_TRUE(0 == ssInfo2.iRemoteAddress.Compare(ssInfoComp.iRemoteAddress));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCUS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CancelUssdSession
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CancelUssdSession
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCancelUssdSession0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
// tests for RMmCustomAPI::CancelUssdSession should be written when ECustomCancelUssdSessionIPC
// would be proccessed.
customAPI.CancelUssdSession( requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSRCN2-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SatRefreshCompleteNotification
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SatRefreshCompleteNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSatRefreshCompleteNotification0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SatRefreshCompleteNotification
// from LTSY.
// The test comes first because the request is self-reposting
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSatRefreshCompleteNotificationIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SatRefreshCompleteNotification when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(ECustomSatRefreshCompleteNotificationIPC, KErrNone);
customAPI.SatRefreshCompleteNotification(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSRCN2-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SatRefreshCompleteNotification
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SatRefreshCompleteNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSatRefreshCompleteNotification0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SatRefreshCompleteNotification
//-------------------------------------------------------------------------
customAPI.SatRefreshCompleteNotification(requestStatus);
iMockLTSY.CompleteL(ECustomSatRefreshCompleteNotificationIPC, KErrNone, 20);
customAPI.CancelAsyncRequest(ECustomSatRefreshCompleteNotificationIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSRCN2-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SatRefreshCompleteNotification
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SatRefreshCompleteNotification
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSatRefreshCompleteNotification0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyNetworkConnectionFailure
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(ECustomSatRefreshCompleteNotificationIPC, KErrNone, 20);
customAPI.SatRefreshCompleteNotification(requestStatus);
customAPI2.SatRefreshCompleteNotification(requestStatus2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCTDDS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckTwoDigitDialSupport
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckTwoDigitDialSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckTwoDigitDialSupport0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TTwoDigitDialSupport support;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckTwoDigitDialSupportIPC, KErrNotSupported);
customAPI.CheckTwoDigitDialSupport(requestStatus, support);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckTwoDigitDialSupportIPC);
const RMmCustomAPI::TTwoDigitDialSupport compData(RMmCustomAPI::ETwoDigitDialSupportOn);
TPckg<RMmCustomAPI::TTwoDigitDialSupport> compPckg(compData);
iMockLTSY.CompleteL( ECustomCheckTwoDigitDialSupportIPC, KErrGeneral, compPckg);
customAPI.CheckTwoDigitDialSupport(requestStatus, support);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::CheckTwoDigitDialSupport when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckTwoDigitDialSupportIPC);
iMockLTSY.CompleteL( ECustomCheckTwoDigitDialSupportIPC, KErrNone, compPckg);
customAPI.CheckTwoDigitDialSupport(requestStatus, support);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compData, support);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::CheckTwoDigitDialSupport
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomCheckTwoDigitDialSupportIPC, KErrNone, compPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCTDDS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::CheckTwoDigitDialSupport
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::CheckTwoDigitDialSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckTwoDigitDialSupport0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TTwoDigitDialSupport support;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::CheckTwoDigitDialSupport
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckTwoDigitDialSupportIPC);
const RMmCustomAPI::TTwoDigitDialSupport compData(RMmCustomAPI::ETwoDigitDialSupportOn);
TPckg<RMmCustomAPI::TTwoDigitDialSupport> compPckg(compData);
iMockLTSY.CompleteL( ECustomCheckTwoDigitDialSupportIPC, KErrNone, compPckg, 20);
customAPI.CheckTwoDigitDialSupport(requestStatus, support);
customAPI.CancelAsyncRequest(ECustomCheckTwoDigitDialSupportIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCTDDS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::CheckTwoDigitDialSupport
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::CheckTwoDigitDialSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckTwoDigitDialSupport0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TTwoDigitDialSupport support;
RMmCustomAPI::TTwoDigitDialSupport support2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::CheckTwoDigitDialSupport
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomCheckTwoDigitDialSupportIPC);
const RMmCustomAPI::TTwoDigitDialSupport compData(RMmCustomAPI::ETwoDigitDialSupportOn);
TPckg<RMmCustomAPI::TTwoDigitDialSupport> compPckg(compData);
iMockLTSY.CompleteL( ECustomCheckTwoDigitDialSupportIPC, KErrNone, compPckg, 20);
customAPI.CheckTwoDigitDialSupport(requestStatus, support);
// second client
iMockLTSY.ExpectL( ECustomCheckTwoDigitDialSupportIPC);
const RMmCustomAPI::TTwoDigitDialSupport compData2(RMmCustomAPI::ETwoDigitDialSupportOff);
TPckg<RMmCustomAPI::TTwoDigitDialSupport> compPckg2(compData2);
iMockLTSY.CompleteL( ECustomCheckTwoDigitDialSupportIPC, KErrNone, compPckg2);
customAPI2.CheckTwoDigitDialSupport(requestStatus2, support2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compData, support);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(compData2, support2);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCCTDDS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::CheckTwoDigitDialSupport with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::CheckTwoDigitDialSupport and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestCheckTwoDigitDialSupport0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TLifeTimeData ltData;
TPckg<RMmCustomAPI::TLifeTimeData> ltPckg(ltData);
iMockLTSY.ExpectL( ECustomCheckTwoDigitDialSupportIPC);
RMmCustomAPI::TTwoDigitDialSupport support;
customAPI.CheckTwoDigitDialSupport(requestStatus, support);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRNS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ResetNetServer
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ResetNetServer
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestResetNetServer0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomResetNetServerIPC, KErrNotSupported);
customAPI.ResetNetServer(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomResetNetServerIPC);
iMockLTSY.CompleteL( ECustomResetNetServerIPC, KErrGeneral);
customAPI.ResetNetServer(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::ResetNetServer when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomResetNetServerIPC);
iMockLTSY.CompleteL( ECustomResetNetServerIPC, KErrNone);
customAPI.ResetNetServer(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::ResetNetServer
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomResetNetServerIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRNS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ResetNetServer
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::ResetNetServer
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestResetNetServer0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::ResetNetServer
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomResetNetServerIPC);
iMockLTSY.CompleteL( ECustomResetNetServerIPC, KErrNone, 20);
customAPI.ResetNetServer(requestStatus);
customAPI.CancelAsyncRequest(ECustomResetNetServerIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRNS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ResetNetServer
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::ResetNetServer
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestResetNetServer0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::ResetNetServer
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomResetNetServerIPC, KErrNone);
iMockLTSY.CompleteL( ECustomResetNetServerIPC, KErrNone, 20);
customAPI.ResetNetServer(requestStatus);
iMockLTSY.ExpectL( ECustomResetNetServerIPC, KErrNone);
iMockLTSY.CompleteL( ECustomResetNetServerIPC, KErrNone);
customAPI2.ResetNetServer(requestStatus2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRNS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ResetNetServer with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ResetNetServer and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestResetNetServer0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
iMockLTSY.ExpectL( ECustomResetNetServerIPC);
customAPI.ResetNetServer(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRF-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReleaseFile
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReleaseFile
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReleaseFile0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
_LIT(KFile, "FileName");
TRequestStatus requestStatus;
customAPI.ReleaseFile( requestStatus, KFile);
// tests for RMmCustomAPI::ReleaseFile should be written when ECustomReleaseFileIPC
// would be proccessed.
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCREF-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::RestartFile
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::RestartFile
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestRestartFile0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
_LIT(KFile, "FileName");
TRequestStatus requestStatus;
// tests for RMmCustomAPI::RestartFile should be written when ECustomRestartFileIPC
// would be proccessed.
customAPI.RestartFile( requestStatus, KFile);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSCTB-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::StartSimCbTopicBrowsing
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::StartSimCbTopicBrowsing
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestStartSimCbTopicBrowsing0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
RBuf8 compData;
CleanupClosePushL(compData);
CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* simTopicArray = new ( ELeave ) CArrayFixFlat
<RMmCustomAPI::TSimCbTopic>(1);
CleanupStack::PushL(simTopicArray);
_LIT(KTopic, "Topic");
RMmCustomAPI::TSimCbTopic topic;
topic.iNumber = 0;
topic.iName.Copy(KTopic);
simTopicArray->AppendL( topic );
TMockLtsyData1< CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* > ltsyData(simTopicArray);
ltsyData.SerialiseL(compData);
iMockLTSY.ExpectL( ECustomStartSimCbTopicBrowsingIPC);
iMockLTSY.CompleteL( ECustomStartSimCbTopicBrowsingIPC, KErrGeneral, compData);
TInt ret = customAPI.StartSimCbTopicBrowsing();
ASSERT_EQUALS(KErrGeneral, ret);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::StartSimCbTopicBrowsing when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomStartSimCbTopicBrowsingIPC);
iMockLTSY.CompleteL( ECustomStartSimCbTopicBrowsingIPC, KErrNone, compData);
ret = customAPI.StartSimCbTopicBrowsing();
ASSERT_EQUALS(KErrNone, ret);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::StartSimCbTopicBrowsing
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomStartSimCbTopicBrowsingIPC, KErrNone, compData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomStartSimCbTopicBrowsingIPC, KErrNotSupported);
ret = customAPI.StartSimCbTopicBrowsing();
ASSERT_EQUALS(KErrNotSupported, ret);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSCTB-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::StartSimCbTopicBrowsing with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::StartSimCbTopicBrowsing with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestStartSimCbTopicBrowsing0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
// Passing zero pointer
iMockLTSY.ExpectL( ECustomStartSimCbTopicBrowsingIPC);
RBuf8 compData;
CleanupClosePushL(compData);
CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* simTopicArray = NULL;
TMockLtsyData1< CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* > ltsyData(simTopicArray);
ltsyData.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomStartSimCbTopicBrowsingIPC, KErrNone, compData);
TInt ret = customAPI.StartSimCbTopicBrowsing();
ASSERT_EQUALS(KErrNone, ret);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSCTB-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::StartSimCbTopicBrowsing with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::StartSimCbTopicBrowsing and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestStartSimCbTopicBrowsing0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
iMockLTSY.ExpectL( ECustomStartSimCbTopicBrowsingIPC);
TInt ret = customAPI.StartSimCbTopicBrowsing();
ASSERT_EQUALS(KErrTimedOut, ret);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGNSCT-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetNextSimCbTopic
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetNextSimCbTopic
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetNextSimCbTopic0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetNextSimCbTopic when result is not cached.
//-------------------------------------------------------------------------
// testing with not initialized topics
RMmCustomAPI::TSimCbTopic topic;
customAPI.GetNextSimCbTopic(requestStatus, topic);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotFound, requestStatus.Int());
AssertMockLtsyStatusL();
_LIT(KTopic, "Topic");
TInt num = 0;
InitSimCbTopicsL(customAPI, KTopic, num);
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::GetNextSimCbTopic when result is not cached.
//-------------------------------------------------------------------------
customAPI.GetNextSimCbTopic(requestStatus, topic);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(num == topic.iNumber);
ASSERT_TRUE(0 == topic.iName.Compare(KTopic));
CleanupStack::PopAndDestroy(2, this);
}
void CCTsyCustomIPCFU::InitSimCbTopicsL(RMmCustomAPI &aCustomApi, const TDesC& aTopic, TInt aNum)
{
RBuf8 compData;
CleanupClosePushL(compData);
CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* simTopicArray = new ( ELeave ) CArrayFixFlat
<RMmCustomAPI::TSimCbTopic>(1);
CleanupStack::PushL(simTopicArray);
RMmCustomAPI::TSimCbTopic topic;
topic.iNumber = aNum;
topic.iName.Copy(aTopic);
simTopicArray->AppendL( topic );
TMockLtsyData1< CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* > ltsyData(simTopicArray);
ltsyData.SerialiseL(compData);
iMockLTSY.ExpectL( ECustomStartSimCbTopicBrowsingIPC);
iMockLTSY.CompleteL( ECustomStartSimCbTopicBrowsingIPC, KErrNone, compData);
TInt ret = aCustomApi.StartSimCbTopicBrowsing();
ASSERT_EQUALS(KErrNone, ret);
CleanupStack::PopAndDestroy(2); //simTopicArray, compData
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDSCT-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DeleteSimCbTopic
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DeleteSimCbTopic
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeleteSimCbTopic0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expectData;
CleanupClosePushL(expectData);
InitSimCbTopicsL(customAPI, _L("Topic"), 0);
TUint index(0);
TUint expIndex(index);
TBool deleteFlag(ETrue);
TMockLtsyData2< TUint, TBool > ltsyData2(expIndex, deleteFlag);
ltsyData2.SerialiseL(expectData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData, KErrNotSupported);
customAPI.DeleteSimCbTopic(requestStatus, index);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData);
iMockLTSY.CompleteL( ECustomDeleteSimCbTopicIPC, KErrGeneral);
customAPI.DeleteSimCbTopic(requestStatus, index);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::DeleteSimCbTopic
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomDeleteSimCbTopicIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: deletion of not existing entry.
//-------------------------------------------------------------------------
index = 100;
expIndex = index;
deleteFlag = EFalse;
expectData.Close();
ltsyData2.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData);
iMockLTSY.CompleteL( ECustomDeleteSimCbTopicIPC, KErrArgument);
customAPI.DeleteSimCbTopic(requestStatus, index);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::DeleteSimCbTopic when result is not cached.
//-------------------------------------------------------------------------
index = 0;
expIndex = index;
deleteFlag = ETrue;
expectData.Close();
ltsyData2.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData);
iMockLTSY.CompleteL( ECustomDeleteSimCbTopicIPC, KErrNone);
customAPI.DeleteSimCbTopic(requestStatus, index);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDSCT-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::DeleteSimCbTopic
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::DeleteSimCbTopic
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeleteSimCbTopic0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
InitSimCbTopicsL(customAPI, _L("Topic"), 0);
TRequestStatus requestStatus;
TUint index(0);
TUint expIndex(index);
TBool deleteFlag(ETrue);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData2< TUint, TBool > ltsyData2(expIndex, deleteFlag);
ltsyData2.SerialiseL(expectData);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::DeleteSimCbTopic
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData);
iMockLTSY.CompleteL( ECustomDeleteSimCbTopicIPC, KErrNone, 20);
customAPI.DeleteSimCbTopic(requestStatus, index);
customAPI.CancelAsyncRequest(ECustomDeleteSimCbTopicIPC);
// operation (ECustomDeleteSimCbTopicIPC) cannot be cancelled on DOS side as per CTSY.
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDSCT-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DeleteSimCbTopic with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DeleteSimCbTopic with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeleteSimCbTopic0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expectData;
CleanupClosePushL(expectData);
TUint index(0);
TUint expIndex(index);
TBool deleteFlag(EFalse);
TMockLtsyData2< TUint, TBool > ltsyData2(expIndex, deleteFlag);
ltsyData2.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData);
iMockLTSY.CompleteL( ECustomDeleteSimCbTopicIPC, KErrNone);
// Successful completion of ECustomDeleteSimCbTopicIPC request in case of not initialized iSimCbTopics
customAPI.DeleteSimCbTopic(requestStatus, index);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDSCT-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::DeleteSimCbTopic
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::DeleteSimCbTopic
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeleteSimCbTopic0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
InitSimCbTopicsL(customAPI, _L("Topic"), 0);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
TUint index(0);
TUint index2(0);
TUint expIndex(index);
TBool deleteFlag(ETrue);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData2< TUint, TBool > ltsyData2(expIndex, deleteFlag);
ltsyData2.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::DeleteSimCbTopic
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData);
iMockLTSY.CompleteL( ECustomDeleteSimCbTopicIPC, KErrNone, 20);
customAPI.DeleteSimCbTopic(requestStatus, index);
customAPI2.DeleteSimCbTopic(requestStatus2, index2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this); // telServer2, phone2, customAPI, customAPI2, expectData, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDSCT-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DeleteSimCbTopic with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DeleteSimCbTopic and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDeleteSimCbTopic0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
InitSimCbTopicsL(customAPI, _L("Topic"), 0);
TRequestStatus requestStatus;
TUint index(0);
TUint expIndex(index);
TBool deleteFlag(ETrue);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData2< TUint, TBool > ltsyData2(expIndex, deleteFlag);
ltsyData2.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomDeleteSimCbTopicIPC, expectData);
customAPI.DeleteSimCbTopic(requestStatus, index);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNNCF-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyNetworkConnectionFailure
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyNetworkConnectionFailure
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyNetworkConnectionFailure0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyNetworkConnectionFailure
// from LTSY.
// The test comes first because the request is self-reposting
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyNetworkConnectionFailureIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyNetworkConnectionFailure when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(ECustomNotifyNetworkConnectionFailureIPC, KErrNone);
customAPI.NotifyNetworkConnectionFailure(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNNCF-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyNetworkConnectionFailure
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyNetworkConnectionFailure
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyNetworkConnectionFailure0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyNetworkConnectionFailure
//-------------------------------------------------------------------------
customAPI.NotifyNetworkConnectionFailure(requestStatus);
iMockLTSY.CompleteL(ECustomNotifyNetworkConnectionFailureIPC, KErrNone, 20);
customAPI.CancelAsyncRequest(ECustomNotifyNetworkConnectionFailureIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNNCF-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyNetworkConnectionFailure
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyNetworkConnectionFailure
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyNetworkConnectionFailure0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyNetworkConnectionFailure
//-------------------------------------------------------------------------
iMockLTSY.CompleteL(ECustomNotifyNetworkConnectionFailureIPC, KErrNone, 20);
customAPI.NotifyNetworkConnectionFailure(requestStatus);
customAPI2.NotifyNetworkConnectionFailure(requestStatus2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAR-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SendAPDUReq
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SendAPDUReq
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSendAPDUReq0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TInt cardReaderId = 1;
_LIT8(KCmdData, "1234");
CmdDataBuf cmdData(KCmdData);
TRequestStatus requestStatus;
RMmCustomAPI::TApduParameters apdu;
apdu.iCardReaderId = cardReaderId;
apdu.iCmdData.Copy(cmdData);
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TMockLtsyData1< RMmCustomAPI::TApduParameters > ltsyData(apdu);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSendAPDUReqV2IPC, expectData, KErrNotSupported);
customAPI.SendAPDUReq(requestStatus, apdu);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSendAPDUReqV2IPC, expectData);
_LIT8(KRspData,"ApduResponse");
RspDataBuf rspData(KRspData);
TMockLtsyData1< RspDataBuf > ltsyRetData(rspData);
ltsyRetData.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomSendAPDUReqV2IPC, KErrGeneral, compData);
customAPI.SendAPDUReq (requestStatus, apdu);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SendAPDUReq when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSendAPDUReqV2IPC, expectData);
iMockLTSY.CompleteL( ECustomSendAPDUReqV2IPC, KErrNone, compData);
customAPI.SendAPDUReq(requestStatus, apdu);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, (apdu.iCardReaderId != cardReaderId)?1:0);
ASSERT_EQUALS(0, apdu.iCmdData.Compare(cmdData));
ASSERT_EQUALS(0, apdu.iRspData.Compare(rspData));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SendAPDUReq
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomSendAPDUReqV2IPC, KErrNone, compData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAR-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SendAPDUReq
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SendAPDUReq
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSendAPDUReq0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TInt cardReaderId = 1;
_LIT8(KCmdData, "1234");
CmdDataBuf cmdData(KCmdData);
TRequestStatus requestStatus;
RMmCustomAPI::TApduParameters apdu;
apdu.iCardReaderId = cardReaderId;
apdu.iCmdData.Copy(cmdData);
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TMockLtsyData1< RMmCustomAPI::TApduParameters > ltsyData(apdu);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SendAPDUReq
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSendAPDUReqV2IPC, expectData);
customAPI.SendAPDUReq(requestStatus, apdu);
customAPI.CancelAsyncRequest(ECustomSendAPDUReqV2IPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
_LIT8(KRspData,"ApduResponse");
RspDataBuf rspData(KRspData);
TMockLtsyData1< RspDataBuf > ltsyRetData(rspData);
ltsyRetData.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomSendAPDUReqV2IPC, KErrNone, compData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAR-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SendAPDUReq with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SendAPDUReq with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSendAPDUReq0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TInt cardReaderId = 1;
_LIT8(KCmdData, "1234");
CmdDataBuf cmdData(KCmdData);
TRequestStatus requestStatus;
RMmCustomAPI::TApduParameters apdu;
apdu.iCardReaderId = cardReaderId;
apdu.iCmdData.Copy(cmdData);
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TMockLtsyData1< RMmCustomAPI::TApduParameters > ltsyData(apdu);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomSendAPDUReqV2IPC, expectData);
customAPI.SendAPDUReq(requestStatus, apdu);
_LIT8(KRspBig,"bigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbigbi");
RspBigBuf bigBuf(KRspBig);
TMockLtsyData1< TBuf8<300> > ltsyDataComp(bigBuf);
ltsyDataComp.SerialiseL(compData);
iMockLTSY.CompleteL( ECustomSendAPDUReqV2IPC, KErrNone, compData);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrOverflow, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAR-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SendAPDUReq
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SendAPDUReq
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSendAPDUReq0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TInt cardReaderId = 1;
_LIT8(KCmdData, "1234");
CmdDataBuf cmdData(KCmdData);
TRequestStatus requestStatus;
RMmCustomAPI::TApduParameters apdu;
apdu.iCardReaderId = cardReaderId;
apdu.iCmdData.Copy(cmdData);
RBuf8 expectData;
CleanupClosePushL(expectData);
RBuf8 compData;
CleanupClosePushL(compData);
TMockLtsyData1< RMmCustomAPI::TApduParameters > ltsyData(apdu);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomSendAPDUReqV2IPC, expectData);
_LIT8(KRspData,"ApduResponse");
RspDataBuf rspData(KRspData);
TMockLtsyData1< TBuf8<20> > ltsyRetData(rspData);
ltsyRetData.SerialiseL(compData);
iMockLTSY.CompleteL(ECustomSendAPDUReqV2IPC, KErrNone, compData, 20);
//sending request to the first client
customAPI.SendAPDUReq(requestStatus, apdu);
TRequestStatus requestStatus2;
RMmCustomAPI::TApduParameters apdu2; // empty request as api cannot be called twice
//sending request to the second client
customAPI2.SendAPDUReq(requestStatus2, apdu2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAR-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SendAPDUReq with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SendAPDUReq and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSendAPDUReq0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
_LIT8(KCmdData, "1234");
CmdDataBuf cmdData(KCmdData);
TRequestStatus requestStatus;
RMmCustomAPI::TApduParameters apdu;
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMmCustomAPI::TApduParameters > ltsyData(apdu);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL(ECustomSendAPDUReqV2IPC, expectData);
customAPI.SendAPDUReq(requestStatus, apdu);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDPL-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DisablePhoneLock
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DisablePhoneLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDisablePhoneLock0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
_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( ECustomDisablePhoneLockIPC, 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( ECustomDisablePhoneLockIPC, expectData);
iMockLTSY.CompleteL( ECustomDisablePhoneLockIPC, 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( ECustomDisablePhoneLockIPC, expectData);
iMockLTSY.CompleteL( ECustomDisablePhoneLockIPC, 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( ECustomDisablePhoneLockIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDPL-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::DisablePhoneLock
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::DisablePhoneLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDisablePhoneLock0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
_LIT(KPassword, "password");
TRequestStatus requestStatus;
RMobilePhone::TMobilePassword pswd(KPassword);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMobilePhone::TMobilePassword > ltsyData(pswd);
ltsyData.SerialiseL(expectData);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::DisablePhoneLock
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomDisablePhoneLockIPC, expectData);
iMockLTSY.CompleteL( ECustomDisablePhoneLockIPC, KErrNone, 20);
customAPI.DisablePhoneLock(requestStatus, pswd);
customAPI.CancelAsyncRequest(ECustomDisablePhoneLockIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDPL-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::DisablePhoneLock
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::DisablePhoneLock
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDisablePhoneLock0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
_LIT(KPassword, "password");
RMobilePhone::TMobilePassword pswd(KPassword);
RMobilePhone::TMobilePassword pswd2(KPassword);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMobilePhone::TMobilePassword > ltsyData(pswd);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::DisablePhoneLock
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomDisablePhoneLockIPC, expectData);
iMockLTSY.CompleteL( ECustomDisablePhoneLockIPC, KErrNone, 20);
customAPI.DisablePhoneLock(requestStatus, pswd);
customAPI2.DisablePhoneLock(requestStatus2, pswd2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCDPL-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::DisablePhoneLock with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::DisablePhoneLock and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestDisablePhoneLock0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
_LIT(KPassword, "password");
TRequestStatus requestStatus;
RMobilePhone::TMobilePassword pswd(KPassword);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMobilePhone::TMobilePassword > ltsyData(pswd);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomDisablePhoneLockIPC, expectData);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 404602);
//Request ECustomDisablePhoneLockIPC is not completed by timeout.
//The test is stopped to avoid blocking of next tests.
ASSERT_TRUE(EFalse);
customAPI.DisablePhoneLock(requestStatus, pswd);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNEIC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyEGprsInfoChange
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyEGprsInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyEGprsInfoChange0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::TGprsInformation info;
TPckg<RMmCustomAPI::TGprsInformation> infoPckg(info);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyEGprsInfoChange
// from LTSY.
//-------------------------------------------------------------------------
TBool lastEdgeGprsSupport = ETrue;
TMockLtsyData1 <TBool> ltsyData(lastEdgeGprsSupport);
ltsyData.SerialiseL(data);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMmTsyNotifyEGprsInfoChangeIPC, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyEGprsInfoChange when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyEGprsInfoChange(requestStatus, infoPckg);
iMockLTSY.CompleteL(EMmTsyNotifyEGprsInfoChangeIPC, KErrNone, data);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::EEdgeGprs == info.iGprsInfo);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::NotifyEGprsInfoChange
//-------------------------------------------------------------------------
lastEdgeGprsSupport = EFalse;
data.Close();
ltsyData.SerialiseL(data);
customAPI.NotifyEGprsInfoChange(requestStatus, infoPckg);
iMockLTSY.CompleteL(EMmTsyNotifyEGprsInfoChangeIPC, KErrNone, data);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::EGprs == info.iGprsInfo);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNEIC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyEGprsInfoChange
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyEGprsInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyEGprsInfoChange0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::TGprsInformation info;
TPckg<RMmCustomAPI::TGprsInformation> infoPckg(info);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyEGprsInfoChange
//-------------------------------------------------------------------------
customAPI.NotifyEGprsInfoChange(requestStatus, infoPckg);
customAPI.CancelAsyncRequest(ECustomNotifyEGprsInfoChange);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
TBool lastEdgeGprsSupport = ETrue;
TMockLtsyData1 <TBool> ltsyData(lastEdgeGprsSupport);
ltsyData.SerialiseL(data);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMmTsyNotifyEGprsInfoChangeIPC, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNEIC-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyEGprsInfoChange with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyEGprsInfoChange with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyEGprsInfoChange0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
TBuf8<1> littleBuf;
//-------------------------------------------------------------------------
// Test on passing too little buffer to NotifyEGprsInfoChange
//-------------------------------------------------------------------------
customAPI.NotifyEGprsInfoChange(requestStatus, littleBuf);
TBool lastEdgeGprsSupport = ETrue;
TMockLtsyData1 <TBool> ltsyData(lastEdgeGprsSupport);
ltsyData.SerialiseL(data);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNEIC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyEGprsInfoChange
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyEGprsInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyEGprsInfoChange0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
RPacketService packetService2;
ret = packetService2.Open(phone2);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(packetService2);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TGprsInformation info;
TPckg<RMmCustomAPI::TGprsInformation> infoPckg(info);
RMmCustomAPI::TGprsInformation info2;
TPckg<RMmCustomAPI::TGprsInformation> infoPckg2(info2);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyEGprsInfoChange
//-------------------------------------------------------------------------
customAPI.NotifyEGprsInfoChange(requestStatus, infoPckg);
customAPI2.NotifyEGprsInfoChange(requestStatus2, infoPckg2);
TBool lastEdgeGprsSupport = ETrue;
TMockLtsyData1 <TBool> ltsyData(lastEdgeGprsSupport);
ltsyData.SerialiseL(data);
iMockLTSY.CompleteL(EMmTsyNotifyEGprsInfoChangeIPC, KErrNone, data, 20);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::EEdgeGprs == info.iGprsInfo);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_TRUE( RMmCustomAPI::EEdgeGprs == info2.iGprsInfo);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(8, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGEI-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetEGprsInfo
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetEGprsInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetEGprsInfo0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
TRequestStatus requestStatus;
RMmCustomAPI::TGprsInformation info;
TPckg<RMmCustomAPI::TGprsInformation> infoPckg(info);
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetEGprsInfo when result is not cached.
//-------------------------------------------------------------------------
customAPI.GetEGprsInfo(requestStatus, infoPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::EGprs == info.iGprsInfo);
AssertMockLtsyStatusL();
// now set EdgeGprs
RBuf8 data;
CleanupClosePushL(data);
TBool lastEdgeGprsSupport = ETrue;
TMockLtsyData1 <TBool> ltsyData(lastEdgeGprsSupport);
ltsyData.SerialiseL(data);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMmTsyNotifyEGprsInfoChangeIPC, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::GetEGprsInfo when EdgeGprs
//-------------------------------------------------------------------------
customAPI.GetEGprsInfo(requestStatus, infoPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( RMmCustomAPI::EEdgeGprs == info.iGprsInfo);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGEI-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetEGprsInfo with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetEGprsInfo with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetEGprsInfo0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TGprsInformation info;
TPckg<RMmCustomAPI::TGprsInformation> infoPckg(info);
// Calling GetEGprsInfo without opening RPacketService
customAPI.GetEGprsInfo(requestStatus, infoPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
// test on passing too little buffer
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
TBuf8<1> littleBuf;
customAPI.GetEGprsInfo(requestStatus, littleBuf);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRSF-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadSimFile
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadSimFile
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadSimFile0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> responce;
RMmCustomAPI::TSimFileInfo fileInfo;
fileInfo.iPath.Fill(0x00);
fileInfo.iOffSet = 0;
fileInfo.iSize = responce.Size();
RMmCustomAPI::TSimFileInfo expFileInfo(fileInfo);
TPckg<RMmCustomAPI::TSimFileInfo> fileInfoPckg(fileInfo);
TMockLtsyData1< RMmCustomAPI::TSimFileInfo > ltsyData(fileInfo);
ltsyData.SerialiseL(expData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData, KErrNotSupported);
customAPI.ReadSimFile(requestStatus, fileInfoPckg, responce);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData);
_LIT8(KResponce, "Responce");
iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrGeneral, KResponce);
customAPI.ReadSimFile(requestStatus, fileInfoPckg, responce);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::ReadSimFile when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData);
iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrNone, KResponce);
customAPI.ReadSimFile(requestStatus, fileInfoPckg, responce);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, responce.Compare(KResponce));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::ReadSimFile
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrNone, KResponce);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRSF-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ReadSimFile
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::ReadSimFile
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadSimFile0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> responce;
RMmCustomAPI::TSimFileInfo fileInfo;
fileInfo.iPath.Fill(0x00);
fileInfo.iOffSet = 0;
fileInfo.iSize = responce.Size();
RMmCustomAPI::TSimFileInfo expFileInfo(fileInfo);
TPckg<RMmCustomAPI::TSimFileInfo> fileInfoPckg(fileInfo);
TMockLtsyData1< RMmCustomAPI::TSimFileInfo > ltsyData(fileInfo);
ltsyData.SerialiseL(expData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::ReadSimFile
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData);
_LIT8(KResponce, "Responce");
iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrNone, KResponce, 20);
customAPI.ReadSimFile(requestStatus, fileInfoPckg, responce);
customAPI.CancelAsyncRequest(ECustomReadSimFileIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRSF-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadSimFile with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadSimFile with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadSimFile0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
RMmCustomAPI::TSimFileInfo fileInfo;
fileInfo.iPath.Fill(0x00);
fileInfo.iOffSet = 0;
fileInfo.iSize = 32;
RMmCustomAPI::TSimFileInfo expFileInfo(fileInfo);
TPckg<RMmCustomAPI::TSimFileInfo> fileInfoPckg(fileInfo);
TBuf8<1> littleBuf;
TMockLtsyData1< RMmCustomAPI::TSimFileInfo > ltsyData(fileInfo);
ltsyData.SerialiseL(expData);
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData);
_LIT8(KResponce, "Responce");
iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrNone, KResponce);
customAPI.ReadSimFile(requestStatus, fileInfoPckg, littleBuf);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrOverflow, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRSF-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ReadSimFile
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::ReadSimFile
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadSimFile0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> responce;
RMmCustomAPI::TSimFileInfo fileInfo;
fileInfo.iPath.Fill(0x00);
fileInfo.iOffSet = 0;
fileInfo.iSize = responce.Size();
RMmCustomAPI::TSimFileInfo expFileInfo(fileInfo);
TPckg<RMmCustomAPI::TSimFileInfo> fileInfoPckg(fileInfo);
TMockLtsyData1< RMmCustomAPI::TSimFileInfo > ltsyData(fileInfo);
ltsyData.SerialiseL(expData);
RBuf8 expData2;
CleanupClosePushL(expData2);
// TMockLtsyData1< RMmCustomAPI::TSimFileInfo > ltsyData2(fileInfo3);
// ltsyData2.SerialiseL(expData3);
TBuf8<32> responce2;
RMmCustomAPI::TSimFileInfo fileInfo2;
fileInfo2.iPath.Fill(0x00);
fileInfo2.iOffSet = 0;
fileInfo2.iSize = responce2.Size();
RMmCustomAPI::TSimFileInfo expFileInfo2(fileInfo2);
TPckg<RMmCustomAPI::TSimFileInfo> fileInfoPckg2(fileInfo2);
RMmCustomAPI::TSimFileInfo fileInfo3;
fileInfo3.iPath.Fill(0x00);
fileInfo3.iOffSet = 0x10;
fileInfo3.iSize = responce2.Size();
RMmCustomAPI::TSimFileInfo expFileInfo3(fileInfo3);
TPckg<RMmCustomAPI::TSimFileInfo> fileInfoPckg3(fileInfo3);
//-------------------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::ReadSimFile - different data
//-------------------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData);
_LIT8(KResponce, "Responce");
iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrNone, KResponce, 20);
customAPI.ReadSimFile(requestStatus, fileInfoPckg, responce);
//iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData2);
//iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrNone, KResponce);
customAPI2.ReadSimFile(requestStatus2, fileInfoPckg2, responce2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, responce.Compare(KResponce));
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(0, responce2.Compare(KResponce));
AssertMockLtsyStatusL();
//-----------------------------------------------------------------------------------
// Test B: Test multiple clients requesting RMmCustomAPI::ReadSimFile with same data
//-----------------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData);
iMockLTSY.CompleteL( ECustomReadSimFileIPC, KErrNone, KResponce, 20);
customAPI.ReadSimFile(requestStatus, fileInfoPckg, responce);
customAPI2.ReadSimFile(requestStatus2, fileInfoPckg3, responce);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, responce.Compare(KResponce));
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(7, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRSF-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadSimFile with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadSimFile and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadSimFile0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> responce;
RMmCustomAPI::TSimFileInfo fileInfo;
fileInfo.iPath.Fill(0x00);
fileInfo.iOffSet = 0;
fileInfo.iSize = responce.Size();
RMmCustomAPI::TSimFileInfo expFileInfo(fileInfo);
TPckg<RMmCustomAPI::TSimFileInfo> fileInfoPckg(fileInfo);
TMockLtsyData1< RMmCustomAPI::TSimFileInfo > ltsyData(fileInfo);
ltsyData.SerialiseL(expData);
iMockLTSY.ExpectL( ECustomReadSimFileIPC, expData);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 404902);
// Location capability missing
customAPI.ReadSimFile(requestStatus, fileInfoPckg, responce);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGLT-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetLifeTime
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetLifeTime
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetLifeTime0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TLifeTimeData ltData;
TPckg<RMmCustomAPI::TLifeTimeData> ltPckg(ltData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetLifeTimeIPC, KErrNotSupported);
customAPI.GetLifeTime(requestStatus, ltPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetLifeTimeIPC);
RMmCustomAPI::TLifeTimeData compData;
compData.iCaps = 0x34; // fill with random data
compData.iHours = 123;
compData.iMinutes = 21;
compData.iManufacturingDate = TDateTime(1,(TMonth)2,3,4,5,6,7);
TPckg<RMmCustomAPI::TLifeTimeData> compPckg(compData);
iMockLTSY.CompleteL( ECustomGetLifeTimeIPC, KErrGeneral, compPckg);
customAPI.GetLifeTime(requestStatus, ltPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetLifeTime when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetLifeTimeIPC);
iMockLTSY.CompleteL( ECustomGetLifeTimeIPC, KErrNone, compPckg);
customAPI.GetLifeTime(requestStatus, ltPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compData.iCaps == ltData.iCaps);
ASSERT_TRUE(compData.iHours == ltData.iHours);
ASSERT_TRUE(compData.iMinutes == ltData.iMinutes);
ASSERT_TRUE(compData.iManufacturingDate.Year() == ltData.iManufacturingDate.Year());
ASSERT_TRUE(compData.iManufacturingDate.Month() == ltData.iManufacturingDate.Month());
ASSERT_TRUE(compData.iManufacturingDate.Day() == ltData.iManufacturingDate.Day());
ASSERT_TRUE(compData.iManufacturingDate.Hour() == ltData.iManufacturingDate.Hour());
ASSERT_TRUE(compData.iManufacturingDate.Minute() == ltData.iManufacturingDate.Minute());
ASSERT_TRUE(compData.iManufacturingDate.Second() == ltData.iManufacturingDate.Second());
ASSERT_TRUE(compData.iManufacturingDate.MicroSecond() == ltData.iManufacturingDate.MicroSecond());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetLifeTime
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetLifeTimeIPC, KErrNone, compPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGLT-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetLifeTime
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetLifeTime
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetLifeTime0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TLifeTimeData ltData;
TPckg<RMmCustomAPI::TLifeTimeData> ltPckg(ltData);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetLifeTime
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetLifeTimeIPC);
RMmCustomAPI::TLifeTimeData compData;
compData.iCaps = 0xFF;
TPckg<RMmCustomAPI::TLifeTimeData> compPckg(compData);
iMockLTSY.CompleteL( ECustomGetLifeTimeIPC, KErrNone, compPckg, 20);
customAPI.GetLifeTime(requestStatus, ltPckg);
customAPI.CancelAsyncRequest(ECustomGetLifeTimeIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGLT-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetLifeTime with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetLifeTime with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetLifeTime0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TBuf8<1> badPckg;
customAPI.GetLifeTime(requestStatus, badPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGLT-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetLifeTime
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetLifeTime
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetLifeTime0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TLifeTimeData ltData;
TPckg<RMmCustomAPI::TLifeTimeData> ltPckg(ltData);
RMmCustomAPI::TLifeTimeData ltData2;
TPckg<RMmCustomAPI::TLifeTimeData> ltPckg2(ltData2);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetLifeTime
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetLifeTimeIPC);
RMmCustomAPI::TLifeTimeData compData;
compData.iCaps = 0x11;
compData.iHours = 111;
compData.iMinutes = 111;
compData.iManufacturingDate = TDateTime(1,(TMonth)1,1,1,1,1,1);
TPckg<RMmCustomAPI::TLifeTimeData> compPckg(compData);
iMockLTSY.CompleteL( ECustomGetLifeTimeIPC, KErrNone, compPckg, 20);
customAPI.GetLifeTime(requestStatus, ltPckg);
customAPI2.GetLifeTime(requestStatus2, ltPckg2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compData.iCaps == ltData.iCaps);
ASSERT_TRUE(compData.iHours == ltData.iHours);
ASSERT_TRUE(compData.iMinutes == ltData.iMinutes);
ASSERT_TRUE(compData.iManufacturingDate.Year() == ltData.iManufacturingDate.Year());
ASSERT_TRUE(compData.iManufacturingDate.Month() == ltData.iManufacturingDate.Month());
ASSERT_TRUE(compData.iManufacturingDate.Day() == ltData.iManufacturingDate.Day());
ASSERT_TRUE(compData.iManufacturingDate.Hour() == ltData.iManufacturingDate.Hour());
ASSERT_TRUE(compData.iManufacturingDate.Minute() == ltData.iManufacturingDate.Minute());
ASSERT_TRUE(compData.iManufacturingDate.Second() == ltData.iManufacturingDate.Second());
ASSERT_TRUE(compData.iManufacturingDate.MicroSecond() == ltData.iManufacturingDate.MicroSecond());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGB-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::Get3GPBInfo
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::Get3GPBInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGet3GPBInfo0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::T3GPBInfo info;
Mem::FillZ((TAny*)&info, sizeof(info));
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::Get3GPBInfo when result is not cached.
// Getting data for uninitialized PB
//-------------------------------------------------------------------------
customAPI.Get3GPBInfo(requestStatus, info);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// for a not initializes PB all values are -1.
ASSERT_TRUE( -1 == info.iMaxLenEmail);
ASSERT_TRUE( -1 == info.iMaxLenSne);
ASSERT_TRUE( -1 == info.iMaxLenAnr);
ASSERT_TRUE( -1 == info.iMaxLenGroupName);
ASSERT_TRUE( -1 == info.iMaxNumEmail);
ASSERT_TRUE( -1 == info.iMaxNumSne);
ASSERT_TRUE( -1 == info.iMaxNumAnr);
ASSERT_TRUE( -1 == info.iMaxNumGroupName);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: Successful completion request of
// RMmCustomAPI::Get3GPBInfo when phoneBookStore is initialized
//-------------------------------------------------------------------------
TName name(KETelIccAdnPhoneBook);
RMobilePhoneBookStore bookStore;
OpenPhoneBookStoreL(bookStore, name, iPhone);
CleanupClosePushL(bookStore);
RBuf8 data;
CleanupClosePushL(data);
CStorageInfoData storageData;
storageData.iADNNumOfEntries = 1;
storageData.iADNTextLengthMax = 2;
storageData.iADNNumberLengthMax = 3;
storageData.iSNENumOfEntries = 4;
storageData.iSNENumOfEntriesPerEntry = 5;
storageData.iSNETextLengthMax = 6;
storageData.iEmailNumOfEntries = 7;
storageData.iEmailNumOfEntriesPerEntry = 8;
storageData.iEmailTextLengthMax = 9;
storageData.iFDNNumOfEntries = 10;
storageData.iFDNTextLengthMax = 11;
storageData.iFDNNumberLengthMax = 12;
storageData.iSDNNumOfEntries = 13;
storageData.iSDNTextLengthMax = 14;
storageData.iSDNNumberLengthMax = 15;
storageData.iVMBXNumOfEntries = 16;
storageData.iVMBXTextLengthMax = 17;
storageData.iVMBXNumberLengthMax = 18;
storageData.iMSISDNNumOfEntries = 19;
storageData.iMSISDNTextLengthMax = 20;
storageData.iMSISDNNumberLengthMax = 21;
storageData.iGRPNumOfEntriesPerEntry = 22;
storageData.iANRNumOfEntries = 23;
storageData.iANRNumOfEntriesPerEntry = 24;
storageData.iANRNumLengthMax = 25;
storageData.iMBDNNumOfEntries = 26;
storageData.iMBDNTextLengthMax = 27;
storageData.iMBDNNumberLengthMax = 28;
TMockLtsyPhoneBookData1< CStorageInfoData > retStoreAndName(name, storageData);
retStoreAndName.SerialiseL(data);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data, 0);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
customAPI.Get3GPBInfo(requestStatus, info);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( storageData.iEmailTextLengthMax == info.iMaxLenEmail);
ASSERT_TRUE( storageData.iSNETextLengthMax == info.iMaxLenSne);
ASSERT_TRUE( storageData.iANRNumLengthMax == info.iMaxLenAnr);
ASSERT_TRUE( -1 == info.iMaxLenGroupName);
ASSERT_TRUE( storageData.iEmailNumOfEntriesPerEntry == info.iMaxNumEmail);
ASSERT_TRUE( storageData.iSNENumOfEntriesPerEntry == info.iMaxNumSne);
ASSERT_TRUE( storageData.iANRNumOfEntriesPerEntry == info.iMaxNumAnr);
ASSERT_TRUE( storageData.iGRPNumOfEntriesPerEntry == info.iMaxNumGroupName);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetSystemNetworkModes
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetSystemNetworkModes
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkModes0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TUint32 modes;
TBool useRats(EFalse);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< TBool > ltsyData(useRats);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetSystemNetworkModesIPC, expectData, KErrNotSupported);
customAPI.GetSystemNetworkModes(requestStatus, modes);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetSystemNetworkModesIPC, expectData);
const TUint32 compModes = 0xFFFF;
TPckg<TUint32> modesPckg(compModes);
iMockLTSY.CompleteL( ECustomGetSystemNetworkModesIPC, KErrGeneral, modesPckg);
customAPI.GetSystemNetworkModes(requestStatus, modes);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetSystemNetworkModes when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetSystemNetworkModesIPC, expectData);
iMockLTSY.CompleteL( ECustomGetSystemNetworkModesIPC, KErrNone, modesPckg);
customAPI.GetSystemNetworkModes(requestStatus, modes);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compModes, modes);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetSystemNetworkModes
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetSystemNetworkModesIPC, KErrNone, modesPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNM-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetSystemNetworkModes
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetSystemNetworkModes
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkModes0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TUint32 modes;
TBool useRats(EFalse);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< TBool > ltsyData(useRats);
ltsyData.SerialiseL(expectData);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetSystemNetworkModes
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetSystemNetworkModesIPC, expectData);
const TUint32 compModes = 0xFFFF;
TPckg<TUint32> modesPckg(compModes);
iMockLTSY.CompleteL( ECustomGetSystemNetworkModesIPC, KErrNone, modesPckg, 20);
customAPI.GetSystemNetworkModes(requestStatus, modes);
customAPI.CancelAsyncRequest(ECustomGetSystemNetworkModesIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNM-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetSystemNetworkModes
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetSystemNetworkModes
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkModes0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
TUint32 modes;
TUint32 modes2;
TBool useRats(EFalse);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< TBool > ltsyData(useRats);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetSystemNetworkModes
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetSystemNetworkModesIPC, expectData);
customAPI.GetSystemNetworkModes(requestStatus, modes);
customAPI2.GetSystemNetworkModes(requestStatus2, modes2);
const TUint32 compModes = 0xFFFF;
TPckg<TUint32> modesPckg(compModes);
iMockLTSY.CompleteL( ECustomGetSystemNetworkModesIPC, KErrNone, modesPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compModes, modes);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNM-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetSystemNetworkModes with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetSystemNetworkModes and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkModes0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TUint32 modes;
TBool useRats(EFalse);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< TBool > ltsyData(useRats);
ltsyData.SerialiseL(expectData);
iMockLTSY.ExpectL( ECustomGetSystemNetworkModesIPC, expectData);
customAPI.GetSystemNetworkModes(requestStatus, modes);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 405201);
//Request ECustomGetSystemNetworkModesIPC is not completed by timeout.
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetSystemNetworkMode
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetSystemNetworkMode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkMode0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TNetworkModeCaps caps(RMmCustomAPI::KCapsNetworkModeGsm);
RMmCustomAPI::TNetworkModeCaps expCaps(caps);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMmCustomAPI::TNetworkModeCaps > ltsyData(expCaps);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetSystemNetworkModeIPC, expectData, KErrNotSupported);
customAPI.SetSystemNetworkMode(requestStatus, caps);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetSystemNetworkModeIPC, expectData);
iMockLTSY.CompleteL( ECustomSetSystemNetworkModeIPC, KErrGeneral);
customAPI.SetSystemNetworkMode(requestStatus, caps);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SetSystemNetworkMode when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetSystemNetworkModeIPC, expectData);
iMockLTSY.CompleteL( ECustomSetSystemNetworkModeIPC, KErrNone);
customAPI.SetSystemNetworkMode(requestStatus, caps);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SetSystemNetworkMode
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomSetSystemNetworkModeIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNM-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SetSystemNetworkMode
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SetSystemNetworkMode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkMode0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TNetworkModeCaps caps(RMmCustomAPI::KCapsNetworkModeGsm);
RMmCustomAPI::TNetworkModeCaps expCaps(caps);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMmCustomAPI::TNetworkModeCaps > ltsyData(expCaps);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::ECustomSetSystemNetworkModeIPC
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetSystemNetworkModeIPC, expectData);
iMockLTSY.CompleteL( ECustomSetSystemNetworkModeIPC, KErrNone, 20);
customAPI.SetSystemNetworkMode(requestStatus, caps);
customAPI.CancelAsyncRequest(ECustomSetSystemNetworkModeIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNM-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SetSystemNetworkMode
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SetSystemNetworkMode
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkMode0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TNetworkModeCaps caps(RMmCustomAPI::KCapsNetworkModeGsm);
RMmCustomAPI::TNetworkModeCaps caps2(RMmCustomAPI::KCapsNetworkModeUmts);
RMmCustomAPI::TNetworkModeCaps expCaps(caps);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMmCustomAPI::TNetworkModeCaps > ltsyData(expCaps);
ltsyData.SerialiseL(expectData);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::SetSystemNetworkMode
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetSystemNetworkModeIPC, expectData, KErrNone);
customAPI.SetSystemNetworkMode(requestStatus, caps);
customAPI2.SetSystemNetworkMode(requestStatus2, caps2);
iMockLTSY.CompleteL( ECustomSetSystemNetworkModeIPC, KErrNone);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNM-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetSystemNetworkMode with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetSystemNetworkMode and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkMode0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TNetworkModeCaps caps(RMmCustomAPI::KCapsNetworkModeGsm);
RMmCustomAPI::TNetworkModeCaps expCaps(caps);
RBuf8 expectData;
CleanupClosePushL(expectData);
TMockLtsyData1< RMmCustomAPI::TNetworkModeCaps > ltsyData(expCaps);
ltsyData.SerialiseL(expectData);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 405302);
//When testing RMmCustomAPI::SetSystemNetworkMode on timeout request ECustomSetSystemNetworkModeIPC
// is not completed. Test is aborted by testexecute.
// test is stopped because otherwise it blockes the next test
ASSERT_TRUE(EFalse);
iMockLTSY.ExpectL( ECustomSetSystemNetworkModeIPC, expectData);
customAPI.SetSystemNetworkMode(requestStatus, caps);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCSNM-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCurrentSystemNetworkModes
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetCurrentSystemNetworkModes
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCurrentSystemNetworkModes0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TUint32 modes;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetCurrentSystemNetworkModesIPC, KErrNotSupported);
customAPI.GetCurrentSystemNetworkModes(requestStatus, modes);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetCurrentSystemNetworkModesIPC);
const TUint32 compModes = 0xFFFF;
TPckg<TUint32> modesPckg(compModes);
iMockLTSY.CompleteL( ECustomGetCurrentSystemNetworkModesIPC, KErrGeneral, modesPckg);
customAPI.GetCurrentSystemNetworkModes(requestStatus, modes);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetCurrentSystemNetworkModes when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetCurrentSystemNetworkModesIPC);
iMockLTSY.CompleteL( ECustomGetCurrentSystemNetworkModesIPC, KErrNone, modesPckg);
customAPI.GetCurrentSystemNetworkModes(requestStatus, modes);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compModes, modes);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetCurrentSystemNetworkModes
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetCurrentSystemNetworkModesIPC, KErrNone, modesPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCSNM-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetCurrentSystemNetworkModes
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetCurrentSystemNetworkModes
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCurrentSystemNetworkModes0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TUint32 modes;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetCurrentSystemNetworkModes
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetCurrentSystemNetworkModesIPC);
const TUint32 compModes = 0xFFFF;
TPckg<TUint32> modesPckg(compModes);
iMockLTSY.CompleteL( ECustomGetCurrentSystemNetworkModesIPC, KErrNone, modesPckg, 20);
customAPI.GetCurrentSystemNetworkModes(requestStatus, modes);
customAPI.CancelAsyncRequest(ECustomGetCurrentSystemNetworkModesIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCSNM-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetCurrentSystemNetworkModes
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetCurrentSystemNetworkModes
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCurrentSystemNetworkModes0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
TUint32 modes;
TUint32 modes2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetCurrentSystemNetworkModes
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetCurrentSystemNetworkModesIPC, KErrNone);
customAPI.GetCurrentSystemNetworkModes(requestStatus, modes);
customAPI2.GetCurrentSystemNetworkModes(requestStatus2, modes2);
const TUint32 compModes = 0xFFFF;
TPckg<TUint32> modesPckg(compModes);
iMockLTSY.CompleteL( ECustomGetCurrentSystemNetworkModesIPC, KErrNone, modesPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCSNM-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCurrentSystemNetworkModes with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetCurrentSystemNetworkModes and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCurrentSystemNetworkModes0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TUint32 modes;
iMockLTSY.ExpectL( ECustomGetCurrentSystemNetworkModesIPC);
customAPI.GetCurrentSystemNetworkModes(requestStatus, modes);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 405401);
//Request ECustomGetCurrentSystemNetworkModesIPC is not completed by timeout.
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSON-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::PowerSimOn
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::PowerSimOn
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOn0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOnIPC, KErrNotSupported);
customAPI.PowerSimOn(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOnIPC);
iMockLTSY.CompleteL( ECustomPowerSimOnIPC, KErrGeneral);
customAPI.PowerSimOn(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::PowerSimOn when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOnIPC);
iMockLTSY.CompleteL( ECustomPowerSimOnIPC, KErrNone);
customAPI.PowerSimOn(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::PowerSimOn
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomPowerSimOnIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSON-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::PowerSimOn
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::PowerSimOn
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOn0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::PowerSimOn
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOnIPC);
iMockLTSY.CompleteL( ECustomPowerSimOnIPC, KErrNone, 20);
customAPI.PowerSimOn(requestStatus);
customAPI.CancelAsyncRequest(ECustomPowerSimOnIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSON-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::PowerSimOn
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::PowerSimOn
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOn0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::PowerSimOn
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOnIPC, KErrNone);
customAPI.PowerSimOn(requestStatus);
customAPI2.PowerSimOn(requestStatus2);
iMockLTSY.CompleteL( ECustomPowerSimOnIPC, KErrNone);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSON-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::PowerSimOn with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::PowerSimOn and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOn0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
iMockLTSY.ExpectL( ECustomPowerSimOnIPC);
customAPI.PowerSimOn(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSOF-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::PowerSimOff
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::PowerSimOff
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOff0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOffIPC, KErrNotSupported);
customAPI.PowerSimOff(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOffIPC);
iMockLTSY.CompleteL( ECustomPowerSimOffIPC, KErrGeneral);
customAPI.PowerSimOff(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::PowerSimOff when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOffIPC);
iMockLTSY.CompleteL( ECustomPowerSimOffIPC, KErrNone);
customAPI.PowerSimOff(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::PowerSimOff
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomPowerSimOffIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSOF-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::PowerSimOff
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::PowerSimOff
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOff0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::PowerSimOff
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOffIPC);
iMockLTSY.CompleteL( ECustomPowerSimOffIPC, KErrNone, 20);
customAPI.PowerSimOff(requestStatus);
customAPI.CancelAsyncRequest(ECustomPowerSimOffIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSOF-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::PowerSimOff
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::PowerSimOff
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOff0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::PowerSimOff
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomPowerSimOffIPC, KErrNone);
customAPI.PowerSimOff(requestStatus);
customAPI2.PowerSimOff(requestStatus2);
iMockLTSY.CompleteL( ECustomPowerSimOffIPC, KErrNone);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCPSOF-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::PowerSimOff with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::PowerSimOff and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestPowerSimOff0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
iMockLTSY.ExpectL( ECustomPowerSimOffIPC);
customAPI.PowerSimOff(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSWR-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SimWarmReset
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SimWarmReset
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSimWarmReset0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSimWarmResetIPC, KErrNotSupported);
customAPI.SimWarmReset(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSimWarmResetIPC);
iMockLTSY.CompleteL( ECustomSimWarmResetIPC, KErrGeneral);
customAPI.SimWarmReset(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SimWarmReset when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSimWarmResetIPC);
iMockLTSY.CompleteL( ECustomSimWarmResetIPC, KErrNone);
customAPI.SimWarmReset(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SimWarmReset
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomSimWarmResetIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSWR-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SimWarmReset
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SimWarmReset
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSimWarmReset0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SimWarmReset
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSimWarmResetIPC);
iMockLTSY.CompleteL( ECustomSimWarmResetIPC, KErrNone, 20);
customAPI.SimWarmReset(requestStatus);
customAPI.CancelAsyncRequest(ECustomSimWarmResetIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSWR-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SimWarmReset
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SimWarmReset
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSimWarmReset0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::SimWarmResetTR
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSimWarmResetIPC, KErrNone);
customAPI.SimWarmReset(requestStatus);
customAPI2.SimWarmReset(requestStatus2);
iMockLTSY.CompleteL( ECustomSimWarmResetIPC, KErrNone);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSWR-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SimWarmReset with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SimWarmReset and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSimWarmReset0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
iMockLTSY.ExpectL( ECustomSimWarmResetIPC);
customAPI.SimWarmReset(requestStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGATR-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetATR
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetATR
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetATR0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> atr;
TBuf8<32> expAtr(atr);
TDesC8* ptr = &expAtr;
TMockLtsyData1< TDesC8* > ltsyData(ptr);
ltsyData.SerialiseL(expData);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetATRIPC, expData, KErrNotSupported);
customAPI.GetATR(requestStatus, atr);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetATRIPC, expData);
_LIT8(KAtr, "ATRATRATR");
iMockLTSY.CompleteL( ECustomGetATRIPC, KErrGeneral, KAtr);
customAPI.GetATR(requestStatus, atr);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetATR when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetATRIPC, expData);
iMockLTSY.CompleteL( ECustomGetATRIPC, KErrNone, KAtr);
customAPI.GetATR(requestStatus, atr);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, atr.Compare(KAtr));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetATR
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetATRIPC, KErrNone, KAtr);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGATR-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetATR
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetATR
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetATR0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> atr;
TBuf8<32> expAtr(atr);
TDesC8* ptr = &expAtr;
TMockLtsyData1< TDesC8* > ltsyData(ptr);
ltsyData.SerialiseL(expData);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetATR
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetATRIPC, expData, KErrNone);
_LIT8(KAtr, "ATRATRATR");
iMockLTSY.CompleteL( ECustomGetATRIPC, KErrNone, KAtr, 20);
customAPI.GetATR(requestStatus, atr);
customAPI.CancelAsyncRequest(ECustomGetATRIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGATR-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetATR with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetATR with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetATR0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<1> atr;
TBuf8<1> expAtr(atr);
TDesC8* ptr = &expAtr;
TMockLtsyData1< TDesC8* > ltsyData(ptr);
ltsyData.SerialiseL(expData);
iMockLTSY.ExpectL( ECustomGetATRIPC, expData, KErrNone);
_LIT8(KAtr, "ATRATRATR");
iMockLTSY.CompleteL( ECustomGetATRIPC, KErrNone, KAtr);
customAPI.GetATR(requestStatus, atr);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrOverflow, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGATR-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetATR
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetATR
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetATR0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> atr;
TBuf8<32> atr2;
TBuf8<32> expAtr(atr);
TDesC8* ptr = &expAtr;
TMockLtsyData1< TDesC8* > ltsyData(ptr);
ltsyData.SerialiseL(expData);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetATR
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetATRIPC, expData, KErrNone);
customAPI.GetATR(requestStatus, atr);
customAPI2.GetATR(requestStatus2, atr2);
_LIT8(KAtr, "ATRATRATR");
iMockLTSY.CompleteL( ECustomGetATRIPC, KErrNone, KAtr);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGATR-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetATR with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetATR and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetATR0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RBuf8 expData;
CleanupClosePushL(expData);
TBuf8<32> atr;
TBuf8<32> expAtr(atr);
TDesC8* ptr = &expAtr;
TMockLtsyData1< TDesC8* > ltsyData(ptr);
ltsyData.SerialiseL(expData);
iMockLTSY.ExpectL( ECustomGetATRIPC, expData, KErrNone);
customAPI.GetATR(requestStatus, atr);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSCRS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetSimCardReaderStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetSimCardReaderStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSimCardReaderStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSimCardReaderStatus status;
status.SetStatus(0x33); //random
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TSimCardReaderStatus expStatus(status);
RMmCustomAPI::TSimCardReaderStatus* expStatusPtr(&expStatus);
TMockLtsyData1< RMmCustomAPI::TSimCardReaderStatus* > ltsyData(expStatusPtr);
ltsyData.SerialiseL(data);
RMmCustomAPI::TSimCardReaderStatus compStatus;
compStatus.SetStatus(0xFF); // random
TPckg<RMmCustomAPI::TSimCardReaderStatus> compStatusPckg(compStatus);
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetSimCardReaderStatus when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data);
iMockLTSY.CompleteL(ECustomGetSimCardReaderStatusIPC, KErrNone, compStatusPckg);
customAPI.GetSimCardReaderStatus(requestStatus, status);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compStatus.GetStatus() == status.GetStatus());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: RMmCustomAPI::GetSimCardReaderStatus completion with zero data
//-------------------------------------------------------------------------
status.SetStatus(0x33);
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data);
iMockLTSY.CompleteL(ECustomGetSimCardReaderStatusIPC, KErrNone, KNullDesC8);
customAPI.GetSimCardReaderStatus(requestStatus, status);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(0 == status.GetStatus());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
expStatus = status;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data, KErrNotSupported);
customAPI.GetSimCardReaderStatus(requestStatus, status);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
expStatus = status;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data);
iMockLTSY.CompleteL(ECustomGetSimCardReaderStatusIPC, KErrGeneral, compStatusPckg);
customAPI.GetSimCardReaderStatus(requestStatus, status);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetSimCardReaderStatus
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetSimCardReaderStatusIPC, KErrNone, compStatusPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
status.SetStatus(0x33); //random
expStatus = status;
data.Close();
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data);
iMockLTSY.CompleteL(ECustomGetSimCardReaderStatusIPC, KErrGeneral, compStatusPckg);
customAPI.GetSimCardReaderStatus(requestStatus, status);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
ASSERT_TRUE(expStatus.GetStatus() == status.GetStatus());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSCRS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetSimCardReaderStatus
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetSimCardReaderStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSimCardReaderStatus0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSimCardReaderStatus status;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
RBuf8 data;
CleanupClosePushL(data);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetSimCardReaderStatus
//-------------------------------------------------------------------------
RMmCustomAPI::TSimCardReaderStatus expStatus(status);
RMmCustomAPI::TSimCardReaderStatus* expStatusPtr(&expStatus);
TMockLtsyData1< RMmCustomAPI::TSimCardReaderStatus* > ltsyData(expStatusPtr);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data);
RMmCustomAPI::TSimCardReaderStatus compStatus;
compStatus.SetStatus(0xFF);
TPckg<RMmCustomAPI::TSimCardReaderStatus> compStatusPckg(compStatus);
iMockLTSY.CompleteL(ECustomGetSimCardReaderStatusIPC, KErrNone, compStatusPckg, 20);
customAPI.GetSimCardReaderStatus(requestStatus, status);
customAPI.CancelAsyncRequest(ECustomGetSimCardReaderStatusIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSCRS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetSimCardReaderStatus
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetSimCardReaderStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSimCardReaderStatus0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetSimCardReaderStatus
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::TSimCardReaderStatus status;
TRequestStatus requestStatus2;
RMmCustomAPI::TSimCardReaderStatus status2;
RMmCustomAPI::TSimCardReaderStatus expStatus(status);
RMmCustomAPI::TSimCardReaderStatus* expStatusPtr(&expStatus);
TMockLtsyData1< RMmCustomAPI::TSimCardReaderStatus* > ltsyData(expStatusPtr);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data);
customAPI.GetSimCardReaderStatus(requestStatus, status);
customAPI2.GetSimCardReaderStatus(requestStatus2, status2);
RMmCustomAPI::TSimCardReaderStatus compStatus;
compStatus.SetStatus(0xFF);
TPckg<RMmCustomAPI::TSimCardReaderStatus> compStatusPckg(compStatus);
iMockLTSY.CompleteL(ECustomGetSimCardReaderStatusIPC, KErrNone, compStatusPckg, 20);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSCRS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetSimCardReaderStatus with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetSimCardReaderStatus and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSimCardReaderStatus0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSimCardReaderStatus status;
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TSimCardReaderStatus expStatus(status);
RMmCustomAPI::TSimCardReaderStatus* expStatusPtr(&expStatus);
TMockLtsyData1< RMmCustomAPI::TSimCardReaderStatus* > ltsyData(expStatusPtr);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomGetSimCardReaderStatusIPC, data);
customAPI.GetSimCardReaderStatus(requestStatus, status);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNSCS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifySimCardStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifySimCardStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifySimCardStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSIMCardStatus cardStatus;
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifySimCardStatus when result is not cached.
//-------------------------------------------------------------------------
RMmCustomAPI::TSIMCardStatus compStatus(RMmCustomAPI::SimCardRemoved);
TPckg<RMmCustomAPI::TSIMCardStatus> compStatusPckg(compStatus);
iMockLTSY.CompleteL(ECustomNotifySimCardStatusIPC, KErrNone, compStatusPckg);
customAPI.NotifySimCardStatus(requestStatus, cardStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compStatus, cardStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifySimCardStatus
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifySimCardStatusIPC, KErrNone, compStatusPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNSCS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifySimCardStatus
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifySimCardStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifySimCardStatus0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSIMCardStatus cardStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifySimCardStatus
//-------------------------------------------------------------------------
customAPI.NotifySimCardStatus(requestStatus, cardStatus);
RMmCustomAPI::TSIMCardStatus compStatus(RMmCustomAPI::SimCardRemoved);
TPckg<RMmCustomAPI::TSIMCardStatus> compStatusPckg(compStatus);
iMockLTSY.CompleteL(ECustomNotifySimCardStatusIPC, KErrNone, compStatusPckg, 20);
customAPI.CancelAsyncRequest(ECustomNotifySimCardStatusIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNSCS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifySimCardStatus
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifySimCardStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifySimCardStatus0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TSIMCardStatus cardStatus;
RMmCustomAPI::TSIMCardStatus cardStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifySimCardStatus
//-------------------------------------------------------------------------
RMmCustomAPI::TSIMCardStatus compStatus(RMmCustomAPI::SimCardRemoved);
TPckg<RMmCustomAPI::TSIMCardStatus> compStatusPckg(compStatus);
iMockLTSY.CompleteL(ECustomNotifySimCardStatusIPC, KErrNone, compStatusPckg, 20);
customAPI.NotifySimCardStatus(requestStatus, cardStatus);
customAPI2.NotifySimCardStatus(requestStatus2, cardStatus2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compStatus, cardStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(compStatus, cardStatus2);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test B: Test multiple clients requesting RMmCustomAPI::NotifySimCardStatus returning SimCardInserted
//-------------------------------------------------------------------------
RMmCustomAPI::TSIMCardStatus compStatusB(RMmCustomAPI::SimCardInserted);
TPckg<RMmCustomAPI::TSIMCardStatus> compStatusPckgB(compStatusB);
iMockLTSY.CompleteL(ECustomNotifySimCardStatusIPC, KErrNone, compStatusPckgB, 20);
cardStatus = RMmCustomAPI::SimCardUnknowError;
cardStatus2 = RMmCustomAPI::SimCardUnknowError;
customAPI.NotifySimCardStatus(requestStatus, cardStatus);
customAPI2.NotifySimCardStatus(requestStatus2, cardStatus2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compStatusB, cardStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(compStatusB, cardStatus2);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGWSAD-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetWlanSimAuthenticationData
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetWlanSimAuthenticationData
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetWlanSimAuthenticationData0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationEapSim compSim;
// get random value
FillRandom(compSim.iSRES);
FillRandom(compSim.iKC);
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> compSimPckg(compSim);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationEapSim sim;
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> simPckg(sim);
// get random value
FillRandom(sim.iRandomParameters);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, simPckg, KErrNotSupported);
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
FillRandom(sim.iRandomParameters);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, simPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrGeneral, compSimPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetWlanSimAuthenticationData when result is not cached.
//-------------------------------------------------------------------------
FillRandom(sim.iRandomParameters);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, simPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compSimPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compSim.iSRES,sim.iSRES);
ASSERT_EQUALS(compSim.iKC, sim.iKC);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetWlanSimAuthenticationData
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compSimPckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test 1 for coverage increasing
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationEapAka simAka;
TPckg<RMmCustomAPI::TSimAuthenticationEapAka> simAkaPckg(simAka);
// get random value
FillRandom(simAka.iRandomParameters);
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationEapAka compSimAka;
// get random value
FillRandom(compSimAka.iCK);
FillRandom(compSimAka.iIK);
FillRandom(compSimAka.iAUTS);
TPckg<RMmCustomAPI::TSimAuthenticationEapAka> compSimAkaPckg(compSimAka);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, simAkaPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compSimAkaPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simAkaPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compSimAka.iCK,simAka.iCK);
ASSERT_EQUALS(compSimAka.iIK, simAka.iIK);
ASSERT_EQUALS(compSimAka.iRES, simAka.iRES);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test 2 for coverage increasing
// completion of RMmCustomAPI::GetWlanSimAuthenticationData
// from LTSY with error and RMmCustomAPI::TSimAuthenticationEapAka as data
//-------------------------------------------------------------------------
FillRandom(simAka.iRandomParameters);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, simAkaPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrGeneral, compSimAkaPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simAkaPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
ASSERT_EQUALS(compSimAka.iAUTS, simAka.iAUTS);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test 3 for coverage increasing
// Unsolicited completion of RMmCustomAPI::GetWlanSimAuthenticationData
// from LTSY with error
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrGeneral, compSimPckg);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test using RMmCustomAPI::TSimAuthenticationGbaBootstrap
//-------------------------------------------------------------------------
// Data for argument
RMmCustomAPI::TSimAuthenticationGbaBootstrap bootstrap;
TPckg<RMmCustomAPI::TSimAuthenticationGbaBootstrap> bootstrapPckg(bootstrap);
// get random values and populate the packages
FillRandom(bootstrap.iRandomParameters);
FillRandom(bootstrap.iAUTN);
// Return parameters
bootstrap.iRES.Fill(0, RMmCustomAPI::KMaxParametersLength);
bootstrap.iAUTS.Fill(0, RMmCustomAPI::KMaxParametersLength);
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationGbaBootstrap compBootstrap;
compBootstrap.iRandomParameters = bootstrap.iRandomParameters;
compBootstrap.iAUTN = bootstrap.iAUTN;
FillRandom(compBootstrap.iRES);
FillRandom(compBootstrap.iAUTS);
TPckg<RMmCustomAPI::TSimAuthenticationGbaBootstrap> compBootstrapPckg(compBootstrap);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, bootstrapPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compBootstrapPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, bootstrapPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compBootstrap.iRandomParameters, bootstrap.iRandomParameters);
ASSERT_EQUALS(compBootstrap.iAUTN, bootstrap.iAUTN);
ASSERT_EQUALS(compBootstrap.iAUTS, bootstrap.iAUTS);
ASSERT_EQUALS(compBootstrap.iRES, bootstrap.iRES);
AssertMockLtsyStatusL();
// completion by error value
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, bootstrapPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrGeneral, compBootstrapPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, bootstrapPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test using RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate bsUpdate;
TPckg<RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate> bsUpdatePckg(bsUpdate);
// --- data for ExpectL ---
FillRandom(bsUpdate.iBTid);
FillRandom(bsUpdate.iKeyLifeTime);
bsUpdate.iRandomParameters.Fill(0, RMmCustomAPI::KMaxParametersLength);
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate compBsUpdate;
compBsUpdate.iBTid = bsUpdate.iBTid;
compBsUpdate.iKeyLifeTime = bsUpdate.iKeyLifeTime;
FillRandom(compBsUpdate.iRandomParameters);
TPckg<RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate> compBsUpdatePckg(compBsUpdate);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, bsUpdatePckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compBsUpdatePckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, bsUpdatePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compBsUpdate.iBTid, bsUpdate.iBTid);
ASSERT_EQUALS(compBsUpdate.iKeyLifeTime, bsUpdate.iKeyLifeTime);
ASSERT_EQUALS(compBsUpdate.iRandomParameters, bsUpdate.iRandomParameters);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test using RMmCustomAPI::TSimAuthenticationGbaNafDerivation
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationGbaNafDerivation naf;
FillRandom(naf.iNafId);
FillRandom(naf.iImpi);
naf.iKsExtNaf.Fill(0, RMmCustomAPI::KMaxParametersLength);
TPckg<RMmCustomAPI::TSimAuthenticationGbaNafDerivation> nafPckg(naf);
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationGbaNafDerivation compNaf;
// get random value
compNaf.iNafId = naf.iNafId;
compNaf.iImpi = naf.iImpi;
FillRandom(compNaf.iKsExtNaf);
TPckg<RMmCustomAPI::TSimAuthenticationGbaNafDerivation> compNafPckg(compNaf);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, nafPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compNafPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, nafPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compNaf.iNafId, naf.iNafId);
ASSERT_EQUALS(compNaf.iImpi, naf.iImpi);
ASSERT_EQUALS(compNaf.iKsExtNaf, naf.iKsExtNaf);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test using RMmCustomAPI::TSimAuthenticationMgvMskUpdate
//-------------------------------------------------------------------------
//Initialize the data to zero
RMmCustomAPI::TSimAuthenticationMgvMskUpdate mskUpd;
mskUpd.iMikey.Fill(0, RMmCustomAPI::KMaxMikeyLength);
mskUpd.iBCASTManagement.Fill(0,RMmCustomAPI::KMaxParametersLength);
mskUpd.iParentalRating.Fill(0,RMmCustomAPI::KMaxKeyGroupIdLength);
mskUpd.iSecurityPolicyExt.Fill(0,RMmCustomAPI::KMaxParametersLength);
TPckg<RMmCustomAPI::TSimAuthenticationMgvMskUpdate> mskUpdPckg(mskUpd);
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationMgvMskUpdate compMskUpd;
// get random value
FillRandom(compMskUpd.iMikey);
FillRandom(compMskUpd.iBCASTManagement);
FillRandom(compMskUpd.iParentalRating);
FillRandom(compMskUpd.iSecurityPolicyExt);
TPckg<RMmCustomAPI::TSimAuthenticationMgvMskUpdate> compMskUpdPckg(compMskUpd);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, mskUpdPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compMskUpdPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, mskUpdPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compMskUpd.iMikey, mskUpd.iMikey);
//Added for MobileTV.
ASSERT_EQUALS(compMskUpd.iBCASTManagement, mskUpd.iBCASTManagement);
ASSERT_EQUALS(compMskUpd.iParentalRating, mskUpd.iParentalRating);
ASSERT_EQUALS(compMskUpd.iSecurityPolicyExt, mskUpd.iSecurityPolicyExt);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test using RMmCustomAPI::TSimAuthenticationMgvMtkGeneration
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationMgvMtkGeneration mtkGen;
FillRandom(mtkGen.iMikey);
mtkGen.iMtkSalt.Fill(0, RMmCustomAPI::KMaxMikeyLength);
mtkGen.iBCASTManagement.Fill(0,RMmCustomAPI::KMaxParametersLength);
mtkGen.iParentalControl.Fill(0,RMmCustomAPI::KMaxKeyGroupIdLength);
mtkGen.iTrafficEncryptionKey.Fill(0,RMmCustomAPI::KMaxParametersLength);
TPckg<RMmCustomAPI::TSimAuthenticationMgvMtkGeneration> mtkGenPckg(mtkGen);
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationMgvMtkGeneration compMtkGen;
// get random value
compMtkGen.iMikey = mtkGen.iMikey;
FillRandom(compMtkGen.iMtkSalt);
FillRandom(compMtkGen.iBCASTManagement);
FillRandom(compMtkGen.iParentalControl);
FillRandom(compMtkGen.iTrafficEncryptionKey);
TPckg<RMmCustomAPI::TSimAuthenticationMgvMtkGeneration> compMtkGenPckg(compMtkGen);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, mtkGenPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compMtkGenPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, mtkGenPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compMtkGen.iMikey, mtkGen.iMikey);
ASSERT_EQUALS(compMtkGen.iMtkSalt, mtkGen.iMtkSalt);
//Added for Mobile TV
ASSERT_EQUALS(compMtkGen.iBCASTManagement, mtkGen.iBCASTManagement);
ASSERT_EQUALS(compMtkGen.iParentalControl, mtkGen.iParentalControl);
ASSERT_EQUALS(compMtkGen.iTrafficEncryptionKey, mtkGen.iTrafficEncryptionKey);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test using RMmCustomAPI::TSimAuthenticationMgvMskDeletion
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationMgvMskDeletion mskDel;
FillRandom(mskDel.iKeyDomainId);
FillRandom(mskDel.iKeyGroupIdPart);
TPckg<RMmCustomAPI::TSimAuthenticationMgvMskDeletion> mskDelPckg(mskDel);
// --- data for CompleteL ---
RMmCustomAPI::TSimAuthenticationMgvMskDeletion compMskDel;
compMskDel.iKeyDomainId = mskDel.iKeyDomainId;
compMskDel.iKeyGroupIdPart = mskDel.iKeyGroupIdPart;
TPckg<RMmCustomAPI::TSimAuthenticationMgvMskDeletion> compMskDelPckg(compMskDel);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, mskDelPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compMskDelPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, mskDelPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(compMskDel.iKeyDomainId, mskDel.iKeyDomainId);
ASSERT_EQUALS(compMskDel.iKeyGroupIdPart, mskDel.iKeyGroupIdPart);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGWSAD-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetWlanSimAuthenticationData
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetWlanSimAuthenticationData
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetWlanSimAuthenticationData0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetWlanSimAuthenticationData
//-------------------------------------------------------------------------
// data for APi
RMmCustomAPI::TSimAuthenticationEapSim sim;
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> simPckg(sim);
// get random value
FillRandom(sim.iRandomParameters);
// data for ExpectL
RMmCustomAPI::TSimAuthenticationEapSim expSim(sim);
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> expSimPckg(expSim);
// data for Complete
RMmCustomAPI::TSimAuthenticationEapSim compSim;
FillRandom(compSim.iSRES);
FillRandom(compSim.iKC);
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> compSimPckg(compSim);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, expSimPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
customAPI.CancelAsyncRequest(ECustomGetSimAuthenticationDataIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGWSAD-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetWlanSimAuthenticationData with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetWlanSimAuthenticationData with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetWlanSimAuthenticationData0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
TInt wrongData (-1); // any value, but not 1 or 2
TPckg<TInt> wrongDataPckg(wrongData);
//-------------------------------------------------------------------------
// Test wrong params, passed from LTSY to CTSY
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationEapAka simAka;
TPckg<RMmCustomAPI::TSimAuthenticationEapAka> simAkaPckg(simAka);
// get random value
FillRandom(simAka.iRandomParameters);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, simAkaPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrArgument, wrongDataPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simAkaPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test Try to use the same Rand twice
//-------------------------------------------------------------------------
RMmCustomAPI::TSimAuthenticationEapSim sim;
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> simPckg(sim);
sim.iRandomParameters.Fill(0x00, RMmCustomAPI::KMaxParametersLength);
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, simPckg);
// use this Rand first time
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
User::WaitForRequest(requestStatus);
// don't check requestStatus cause it depends on if rand_db.cur exists or not
// use this Rand second time
// CTSY should complete request with KErrArgument
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// Test wrong params, passed to API
//-------------------------------------------------------------------------
// CTSY (CustomAPI) checks whether passed parameters are wrong.
// if they are wrong than it completes request
// and sends request with wrong parameter to LSTY !!!
customAPI.GetWlanSimAuthenticationData(requestStatus, wrongDataPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
// Done !
CleanupStack::PopAndDestroy (2, this); //customAPI
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGWSAD-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetWlanSimAuthenticationData
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetWlanSimAuthenticationData
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetWlanSimAuthenticationData0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
// data for the first APi
RMmCustomAPI::TSimAuthenticationEapAka simAka;
TPckg<RMmCustomAPI::TSimAuthenticationEapAka> simPckg(simAka);
FillRandom(simAka.iRandomParameters);
// data for the first ExpectL
RMmCustomAPI::TSimAuthenticationEapAka expSimAka(simAka);
TPckg<RMmCustomAPI::TSimAuthenticationEapAka> expSimPckg(expSimAka);
// data for the first Complete
RMmCustomAPI::TSimAuthenticationEapAka compSimAka;
TPckg<RMmCustomAPI::TSimAuthenticationEapAka> compSimPckg(compSimAka);
// data for second APi
RMmCustomAPI::TSimAuthenticationEapSim sim2;
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> simPckg2(sim2);
FillRandom(sim2.iRandomParameters);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetWlanSimAuthenticationData
//-------------------------------------------------------------------------
// first request
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, expSimPckg);
iMockLTSY.CompleteL(ECustomGetSimAuthenticationDataIPC, KErrNone, compSimPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
// second request
customAPI2.GetWlanSimAuthenticationData(requestStatus2, simPckg2);
// wait for the first answer
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
// wait for the second answer
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGWSAD-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetWlanSimAuthenticationData with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetWlanSimAuthenticationData and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetWlanSimAuthenticationData0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
// data for APi
RMmCustomAPI::TSimAuthenticationEapSim sim;
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> simPckg(sim);
FillRandom(sim.iRandomParameters);
// data for t ExpectL
RMmCustomAPI::TSimAuthenticationEapSim expSim(sim);
TPckg<RMmCustomAPI::TSimAuthenticationEapSim> expSimPckg(expSim);
//-------------------------------------------------------------------------
// Test A: Test timeout of RMmCustomAPI::GetWlanSimAuthenticationData
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetSimAuthenticationDataIPC, expSimPckg);
customAPI.GetWlanSimAuthenticationData(requestStatus, simPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
// Done !
CleanupStack::PopAndDestroy(2, this); // customAPI
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSMSR-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetSimMessageStatusRead
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetSimMessageStatusRead
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSimMessageStatusRead0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
TTime time;
time.UniversalTime();
TInt timeZone(1);
TTime expTime(time);
TInt expTimeZone(timeZone);
TMockLtsyData2< TTime, TInt > ltsyData(expTime, expTimeZone);
ltsyData.SerialiseL(data);
// Actually the function does not have any opportunity to return error value.
// Perhaps this is a design error...
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetSimMessageStatusReadIPC, data, KErrNotSupported);
customAPI.SetSimMessageStatusRead(time, timeZone);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SetSimMessageStatusRead when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetSimMessageStatusReadIPC, data, KErrNone);
customAPI.SetSimMessageStatusRead(time, timeZone);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZUS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneUHZIUESettings0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TViagUHZIUESettings settings;
settings.iSettings = 0xFF;
settings.iVersion = 1;
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TViagUHZIUESettings expSettings = settings;
TMockLtsyData1< RMmCustomAPI::TViagUHZIUESettings > ltsyData(expSettings);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EWriteViagHomeZoneUHZIUESettingsIPC, data, KErrNotSupported);
customAPI.WriteViagHomeZoneUHZIUESettings(requestStatus, settings);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EWriteViagHomeZoneUHZIUESettingsIPC, data);
iMockLTSY.CompleteL(EWriteViagHomeZoneUHZIUESettingsIPC, KErrGeneral);
customAPI.WriteViagHomeZoneUHZIUESettings(requestStatus, settings);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyRauEvent when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EWriteViagHomeZoneUHZIUESettingsIPC, data);
iMockLTSY.CompleteL(EWriteViagHomeZoneUHZIUESettingsIPC, KErrNone);
customAPI.WriteViagHomeZoneUHZIUESettings(requestStatus, settings);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyRauEvent
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EWriteViagHomeZoneUHZIUESettingsIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZUS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneUHZIUESettings0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRequestStatus requestStatus;
RMmCustomAPI::TViagUHZIUESettings settings;
settings.iSettings = 0xFF;
settings.iVersion = 1;
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TViagUHZIUESettings expSettings = settings;
TMockLtsyData1< RMmCustomAPI::TViagUHZIUESettings > ltsyData(expSettings);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EWriteViagHomeZoneUHZIUESettingsIPC, data);
iMockLTSY.CompleteL(EWriteViagHomeZoneUHZIUESettingsIPC, KErrNone, 20);
customAPI.WriteViagHomeZoneUHZIUESettings(requestStatus, settings);
customAPI.CancelAsyncRequest(EWriteViagHomeZoneUHZIUESettingsIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZUS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneUHZIUESettings0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TViagUHZIUESettings settings;
RMmCustomAPI::TViagUHZIUESettings settings2;
settings.iSettings = 0xFF;
settings.iVersion = 1;
RMmCustomAPI::TViagUHZIUESettings expSettings = settings;
TMockLtsyData1< RMmCustomAPI::TViagUHZIUESettings > ltsyData(expSettings);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::WriteViagHomeZoneUHZIUESettings
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EWriteViagHomeZoneUHZIUESettingsIPC, data);
iMockLTSY.CompleteL(EWriteViagHomeZoneUHZIUESettingsIPC, KErrNone, 20);
customAPI.WriteViagHomeZoneUHZIUESettings(requestStatus, settings);
customAPI2.WriteViagHomeZoneUHZIUESettings(requestStatus2, settings2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWVHZUS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::WriteViagHomeZoneUHZIUESettings with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::WriteViagHomeZoneUHZIUESettings and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteViagHomeZoneUHZIUESettings0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TViagUHZIUESettings settings = {0, 0};
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TViagUHZIUESettings expSettings = settings;
TMockLtsyData1< RMmCustomAPI::TViagUHZIUESettings > ltsyData(expSettings);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(EWriteViagHomeZoneUHZIUESettingsIPC, data);
customAPI.WriteViagHomeZoneUHZIUESettings(requestStatus, settings);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAO-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetAlwaysOn
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetAlwaysOn
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlwaysOn0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
RMmCustomAPI::TSetAlwaysOnMode expMode = RMmCustomAPI::EAlwaysModeBoth;
TMockLtsyData1 <RMmCustomAPI::TSetAlwaysOnMode> expData(expMode);
expData.SerialiseL(expectData);
RMmCustomAPI::TSetAlwaysOnMode mode = RMmCustomAPI::EAlwaysModeBoth;
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlwaysOnMode, expectData);
TInt result = 0;
TMockLtsyData1 <TInt> ltsyData(result);
ltsyData.SerialiseL(data);
iMockLTSY.CompleteL(ECustomSetAlwaysOnMode, KErrGeneral, data);
customAPI.SetAlwaysOn(requestStatus, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SetAlwaysOn
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomSetAlwaysOnMode, KErrNone, data);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlwaysOnMode, expectData, KErrNotSupported);
customAPI.SetAlwaysOn(requestStatus, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SetAlwaysOn when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlwaysOnMode, expectData);
iMockLTSY.CompleteL(ECustomSetAlwaysOnMode, KErrNone, data);
customAPI.SetAlwaysOn(requestStatus, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAO-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SetAlwaysOn
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SetAlwaysOn
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlwaysOn0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
RMmCustomAPI::TSetAlwaysOnMode expMode = RMmCustomAPI::EAlwaysModeBoth;
TMockLtsyData1 <RMmCustomAPI::TSetAlwaysOnMode> expData(expMode);
expData.SerialiseL(expectData);
RMmCustomAPI::TSetAlwaysOnMode mode = RMmCustomAPI::EAlwaysModeBoth;
TInt result = 0;
TMockLtsyData1 <TInt> ltsyData(result);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SetAlwaysOn
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomSetAlwaysOnMode, expectData);
//iMockLTSY.CompleteL(ECustomSetAlwaysOnMode, KErrNone, data, 20);
customAPI.SetAlwaysOn(requestStatus, mode);
customAPI.CancelAsyncRequest(ECustomSetAlwaysOnMode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAO-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetAlwaysOn with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetAlwaysOn with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlwaysOn0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TSetAlwaysOnMode mode = RMmCustomAPI::EAlwaysModeBoth;
customAPI.SetAlwaysOn(requestStatus, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSAO-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SetAlwaysOn
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SetAlwaysOn
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetAlwaysOn0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RPacketService packetService;
OpenPacketServiceL(packetService);
CleanupClosePushL(packetService);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
RBuf8 data;
CleanupClosePushL(data);
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
RMmCustomAPI::TSetAlwaysOnMode expMode = RMmCustomAPI::EAlwaysModeBoth;
TRequestStatus requestStatus2;
TMockLtsyData1 <RMmCustomAPI::TSetAlwaysOnMode> expData(expMode);
expData.SerialiseL(expectData);
RMmCustomAPI::TSetAlwaysOnMode mode = RMmCustomAPI::EAlwaysModeBoth;
RMmCustomAPI::TSetAlwaysOnMode mode2 = RMmCustomAPI::EAlwaysModeBoth;
TInt result = 0;
TMockLtsyData1 <TInt> ltsyData(result);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomSetAlwaysOnMode, expectData);
iMockLTSY.CompleteL(ECustomSetAlwaysOnMode, KErrNone, data, 20);
customAPI.SetAlwaysOn(requestStatus, mode);
customAPI2.SetAlwaysOn(requestStatus2, mode2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(8, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNRE-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyRauEvent
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyRauEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyRauEvent0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyRauEvent
// from LTSY.
//-------------------------------------------------------------------------
RMmCustomAPI::TRauEventStatus completeStatus(RMmCustomAPI::ERauEventResumed);
TPckg<RMmCustomAPI::TRauEventStatus> completePckg(completeStatus);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyRauEventIPC, KErrNone, completePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::TRauEventStatus status(RMmCustomAPI::ERauEventActive);
customAPI.NotifyRauEvent(requestStatus, status);
iMockLTSY.CompleteL(ECustomNotifyRauEventIPC, KErrGeneral, completePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyRauEvent when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyRauEvent(requestStatus, status);
completeStatus = RMmCustomAPI::ERauEventResumed;
iMockLTSY.CompleteL(ECustomNotifyRauEventIPC, KErrNone, completePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(completeStatus, status);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNRE-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyRauEvent
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyRauEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyRauEvent0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyRauEvent
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::TRauEventStatus status;
customAPI.NotifyRauEvent(requestStatus, status);
customAPI.CancelAsyncRequest(ECustomNotifyRauEventIPC);
RMmCustomAPI::TRauEventStatus completeStatus(RMmCustomAPI::ERauEventActive);
TPckg<RMmCustomAPI::TRauEventStatus> completePckg(completeStatus);
iMockLTSY.CompleteL(ECustomNotifyRauEventIPC, KErrNone, completePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNRE-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyRauEvent
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyRauEvent
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyRauEvent0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TRauEventStatus status(RMmCustomAPI::ERauEventActive);
RMmCustomAPI::TRauEventStatus status2(RMmCustomAPI::ERauEventActive);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyRauEvent
//-------------------------------------------------------------------------
customAPI.NotifyRauEvent(requestStatus, status);
customAPI2.NotifyRauEvent(requestStatus2, status2);
RMmCustomAPI::TRauEventStatus completeStatus(RMmCustomAPI::ERauEventResumed);
TPckg<RMmCustomAPI::TRauEventStatus> completePckg(completeStatus);
iMockLTSY.CompleteL(ECustomNotifyRauEventIPC, KErrNone, completePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(completeStatus, status);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(completeStatus, status2);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRHS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadHSxPAStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus(RMmCustomAPI::EHSxPADisabled);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomReadHSxPAStatusIPC, KErrNotSupported);
customAPI.ReadHSxPAStatus(requestStatus, paStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomReadHSxPAStatusIPC);
customAPI.ReadHSxPAStatus(requestStatus, paStatus);
RMmCustomAPI::THSxPAStatus paStatusComplete(RMmCustomAPI::EHSxPAEnabled);
TPckg<RMmCustomAPI::THSxPAStatus> paStatusCompletePckg(paStatusComplete);
iMockLTSY.CompleteL(ECustomReadHSxPAStatusIPC, KErrGeneral, paStatusCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::ReadHSxPAStatus when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomReadHSxPAStatusIPC);
customAPI.ReadHSxPAStatus(requestStatus, paStatus);
iMockLTSY.CompleteL(ECustomReadHSxPAStatusIPC, KErrNone, paStatusCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(paStatusComplete, paStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C2: read another value
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomReadHSxPAStatusIPC);
customAPI.ReadHSxPAStatus(requestStatus, paStatus);
paStatusComplete = RMmCustomAPI::EHSxPADisabled;
iMockLTSY.CompleteL(ECustomReadHSxPAStatusIPC, KErrNone, paStatusCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(paStatusComplete, paStatus);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::ReadHSxPAStatus
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomReadHSxPAStatusIPC, KErrNone, paStatusCompletePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRHS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::ReadHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::ReadHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadHSxPAStatus0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus;
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::ReadHSxPAStatus
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomReadHSxPAStatusIPC);
customAPI.ReadHSxPAStatus(requestStatus, paStatus);
customAPI.CancelAsyncRequest(ECustomReadHSxPAStatusIPC);
RMmCustomAPI::THSxPAStatus paStatusComplete(RMmCustomAPI::EHSxPAEnabled);
TPckg<RMmCustomAPI::THSxPAStatus> paStatusCompletePckg(paStatusComplete);
iMockLTSY.CompleteL(ECustomReadHSxPAStatusIPC, KErrNone, paStatusCompletePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRHS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::ReadHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::ReadHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadHSxPAStatus0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::THSxPAStatus paStatus;
RMmCustomAPI::THSxPAStatus paStatus2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::ReadHSxPAStatus
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomReadHSxPAStatusIPC);
customAPI.ReadHSxPAStatus(requestStatus, paStatus);
customAPI2.ReadHSxPAStatus(requestStatus2, paStatus2);
RMmCustomAPI::THSxPAStatus paStatusComplete(RMmCustomAPI::EHSxPAEnabled);
TPckg<RMmCustomAPI::THSxPAStatus> paStatusCompletePckg(paStatusComplete);
iMockLTSY.CompleteL(ECustomReadHSxPAStatusIPC, KErrNone, paStatusCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(paStatusComplete, paStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCRHS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::ReadHSxPAStatus with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::ReadHSxPAStatus and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestReadHSxPAStatus0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus;
iMockLTSY.ExpectL(ECustomReadHSxPAStatusIPC);
customAPI.ReadHSxPAStatus(requestStatus, paStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWHS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::WriteHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::WriteHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteHSxPAStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus(RMmCustomAPI::EHSxPADisabled);
TMockLtsyData1< RMmCustomAPI::THSxPAStatus > tsyData(paStatus);
tsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomWriteHSxPAStatusIPC, data, KErrNotSupported);
customAPI.WriteHSxPAStatus(requestStatus, paStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomWriteHSxPAStatusIPC, data);
customAPI.WriteHSxPAStatus(requestStatus, paStatus);
iMockLTSY.CompleteL(ECustomWriteHSxPAStatusIPC, KErrGeneral);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::WriteHSxPAStatus when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomWriteHSxPAStatusIPC, data);
customAPI.WriteHSxPAStatus(requestStatus, paStatus);
iMockLTSY.CompleteL(ECustomWriteHSxPAStatusIPC, KErrNone);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::WriteHSxPAStatus
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomWriteHSxPAStatusIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWHS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::WriteHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::WriteHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteHSxPAStatus0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus(RMmCustomAPI::EHSxPADisabled);
TMockLtsyData1< RMmCustomAPI::THSxPAStatus > tsyData(paStatus);
tsyData.SerialiseL(data);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::WriteHSxPAStatus
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomWriteHSxPAStatusIPC, data);
customAPI.WriteHSxPAStatus(requestStatus, paStatus);
customAPI.CancelAsyncRequest(ECustomWriteHSxPAStatusIPC);
iMockLTSY.CompleteL(ECustomWriteHSxPAStatusIPC, KErrNone);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWHS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::WriteHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::WriteHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteHSxPAStatus0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
CleanupClosePushL(customAPI2);
customAPI2.Open(phone2);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::THSxPAStatus paStatus(RMmCustomAPI::EHSxPADisabled);
TMockLtsyData1< RMmCustomAPI::THSxPAStatus > tsyData(paStatus);
tsyData.SerialiseL(data);
RMmCustomAPI::THSxPAStatus paStatus2(RMmCustomAPI::EHSxPAEnabled);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::WriteHSxPAStatus
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomWriteHSxPAStatusIPC, data);
customAPI.WriteHSxPAStatus(requestStatus, paStatus);
customAPI2.WriteHSxPAStatus(requestStatus2, paStatus2);
iMockLTSY.CompleteL(ECustomWriteHSxPAStatusIPC, KErrNone);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCWHS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::WriteHSxPAStatus with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::WriteHSxPAStatus and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestWriteHSxPAStatus0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 data;
CleanupClosePushL(data);
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus(RMmCustomAPI::EHSxPADisabled);
TMockLtsyData1< RMmCustomAPI::THSxPAStatus > tsyData(paStatus);
tsyData.SerialiseL(data);
iMockLTSY.ExpectL(ECustomWriteHSxPAStatusIPC, data);
customAPI.WriteHSxPAStatus(requestStatus, paStatus);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNHS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyHSxPAStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyHSxPAStatus
// from LTSY.
//-------------------------------------------------------------------------
RMmCustomAPI::THSxPAStatus paCompleteStatus(RMmCustomAPI::EHSxPAEnabled);
TPckg<RMmCustomAPI::THSxPAStatus> completePckg(paCompleteStatus);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyHSxPAStatusIPC, KErrNone, completePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus(RMmCustomAPI::EHSxPADisabled);
customAPI.NotifyHSxPAStatus(requestStatus, paStatus);
iMockLTSY.CompleteL(ECustomNotifyHSxPAStatusIPC, KErrGeneral, completePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyHSxPAStatus when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyHSxPAStatus(requestStatus, paStatus);
paCompleteStatus = RMmCustomAPI::EHSxPAEnabled;
iMockLTSY.CompleteL(ECustomNotifyHSxPAStatusIPC, KErrNone, completePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(paCompleteStatus, paStatus);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNHS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyHSxPAStatus0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyHSxPAStatus
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::THSxPAStatus paStatus;
customAPI.NotifyHSxPAStatus(requestStatus, paStatus);
customAPI.CancelAsyncRequest(ECustomNotifyHSxPAStatusIPC);
RMmCustomAPI::THSxPAStatus paCompleteStatus(RMmCustomAPI::EHSxPADisabled);
TPckg<RMmCustomAPI::THSxPAStatus> completePckg(paCompleteStatus);
iMockLTSY.CompleteL(ECustomNotifyHSxPAStatusIPC, KErrNone, completePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNHS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyHSxPAStatus
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyHSxPAStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyHSxPAStatus0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
CleanupClosePushL(customAPI2);
customAPI2.Open(phone2);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::THSxPAStatus paStatus(RMmCustomAPI::EHSxPADisabled);
RMmCustomAPI::THSxPAStatus paStatus2(RMmCustomAPI::EHSxPADisabled);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyHSxPAStatus
//-------------------------------------------------------------------------
customAPI.NotifyHSxPAStatus(requestStatus, paStatus);
customAPI2.NotifyHSxPAStatus(requestStatus2, paStatus2);
RMmCustomAPI::THSxPAStatus paCompleteStatus(RMmCustomAPI::EHSxPAEnabled);
TPckg<RMmCustomAPI::THSxPAStatus> completePckg(paCompleteStatus);
iMockLTSY.CompleteL(ECustomNotifyHSxPAStatusIPC, KErrNone, completePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(paCompleteStatus, paStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(paCompleteStatus, paStatus2);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGICFIS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetIccCallForwardingIndicatorStatus
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetIccCallForwardingIndicatorStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetIccCallForwardingIndicatorStatus0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TCFIndicators indi;
RMmCustomAPI::TCFIndicatorsPckg indiPckg(indi);
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
customAPI.GetIccCallForwardingIndicatorStatus(requestStatus, indiPckg);
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
_LIT(KNumber, "123456789");
indiComplete.iIndicator = 0xFF;
indiComplete.iCFNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;
indiComplete.iCFNumber.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
indiComplete.iCFNumber.iTelNumber = KNumber;
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrGeneral, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetIccCallForwardingIndicatorStatus when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
customAPI.GetIccCallForwardingIndicatorStatus(requestStatus, indiPckg);
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(indiComplete.iIndicator, indi.iIndicator);
ASSERT_EQUALS(indiComplete.iCFNumber.iTypeOfNumber, indi.iCFNumber.iTypeOfNumber);
ASSERT_EQUALS(indiComplete.iCFNumber.iNumberPlan, indi.iCFNumber.iNumberPlan);
ASSERT_EQUALS(0, indi.iCFNumber.iTelNumber.Compare(indiComplete.iCFNumber.iTelNumber));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetIccCallForwardingIndicatorStatus
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
// here iGetIccCfStatusBootUp is true and error is set
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrGeneral, indiCompletePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// TEST E2: Unsolicited completion of RMmCustomAPI::GetIccCallForwardingIndicatorStatus
// from LTSY.
// here iGetIccCfStatusBootUp is true and no error
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
// TEST E3: Unsolicited completion of RMmCustomAPI::GetIccCallForwardingIndicatorStatus
// from LTSY.
// here iGetIccCfStatusBootUp is false
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC, KErrNotSupported);
customAPI.GetIccCallForwardingIndicatorStatus(requestStatus, indiPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGICFIS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetIccCallForwardingIndicatorStatus
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetIccCallForwardingIndicatorStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetIccCallForwardingIndicatorStatus0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
// This completes request made when customAPI is opened
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrNone, indiCompletePckg);
TRequestStatus requestStatus;
RMmCustomAPI::TCFIndicators indi;
RMmCustomAPI::TCFIndicatorsPckg indiPckg(indi);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetIccCallForwardingIndicatorStatus
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
customAPI.GetIccCallForwardingIndicatorStatus(requestStatus, indiPckg);
customAPI.CancelAsyncRequest(ECustomGetIccCallForwardingStatusIPC);
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGICFIS-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetIccCallForwardingIndicatorStatus with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetIccCallForwardingIndicatorStatus with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetIccCallForwardingIndicatorStatus0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMmCustomAPI::GetIccCallForwardingIndicatorStatus
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TBuf8<1> littleBuf;
customAPI.GetIccCallForwardingIndicatorStatus(requestStatus, littleBuf);
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGICFIS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetIccCallForwardingIndicatorStatus
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetIccCallForwardingIndicatorStatus
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetIccCallForwardingIndicatorStatus0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
CleanupClosePushL(customAPI2);
customAPI2.Open(phone2);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TCFIndicators indi;
RMmCustomAPI::TCFIndicatorsPckg indiPckg(indi);
RMmCustomAPI::TCFIndicators indi2;
RMmCustomAPI::TCFIndicatorsPckg indiPckg2(indi2);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetIccCallForwardingIndicatorStatus
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
customAPI.GetIccCallForwardingIndicatorStatus(requestStatus, indiPckg);
customAPI2.GetIccCallForwardingIndicatorStatus(requestStatus2, indiPckg2);
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
iMockLTSY.CompleteL(ECustomGetIccCallForwardingStatusIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGICFIS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetIccCallForwardingIndicatorStatus with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetIccCallForwardingIndicatorStatus and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetIccCallForwardingIndicatorStatus0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TCFIndicators indi;
RMmCustomAPI::TCFIndicatorsPckg indiPckg(indi);
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
customAPI.GetIccCallForwardingIndicatorStatus(requestStatus, indiPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNICFSC-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyIccCallForwardingStatusChange
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyIccCallForwardingStatusChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyIccCallForwardingStatusChange0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TCFIndicators indi;
RMmCustomAPI::TCFIndicatorsPckg indiPckg(indi);
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
customAPI.NotifyIccCallForwardingStatusChange(requestStatus, indiPckg);
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
indiComplete.iIndicator = 0xFF;
iMockLTSY.CompleteL(ECustomNotifyIccCallForwardingStatusChangeIPC, KErrGeneral, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyIccCallForwardingStatusChange when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyIccCallForwardingStatusChange(requestStatus, indiPckg);
_LIT(KNumber, "123456789");
indiComplete.iIndicator = 0x00;
indiComplete.iCFNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;
indiComplete.iCFNumber.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
indiComplete.iCFNumber.iTelNumber = KNumber;
iMockLTSY.CompleteL(ECustomNotifyIccCallForwardingStatusChangeIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(indiComplete.iIndicator, indi.iIndicator);
ASSERT_EQUALS(indiComplete.iCFNumber.iTypeOfNumber, indi.iCFNumber.iTypeOfNumber);
ASSERT_EQUALS(indiComplete.iCFNumber.iNumberPlan, indi.iCFNumber.iNumberPlan);
ASSERT_EQUALS(0, indi.iCFNumber.iTelNumber.Compare(indiComplete.iCFNumber.iTelNumber));
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyIccCallForwardingStatusChange
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
indiComplete.iIndicator = 0xFF;
iMockLTSY.CompleteL(ECustomNotifyIccCallForwardingStatusChangeIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNICFSC-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyIccCallForwardingStatusChange
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyIccCallForwardingStatusChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyIccCallForwardingStatusChange0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
TRequestStatus requestStatus;
RMmCustomAPI::TCFIndicators indi;
RMmCustomAPI::TCFIndicatorsPckg indiPckg(indi);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyIccCallForwardingStatusChange
//-------------------------------------------------------------------------
customAPI.NotifyIccCallForwardingStatusChange(requestStatus, indiPckg);
customAPI.CancelAsyncRequest(ECustomNotifyIccCallForwardingStatusChangeIPC);
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
indiComplete.iIndicator = 0xFF;
iMockLTSY.CompleteL(ECustomNotifyIccCallForwardingStatusChangeIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNICFSC-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyIccCallForwardingStatusChange with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyIccCallForwardingStatusChange with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyIccCallForwardingStatusChange0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMmCustomAPI::NotifyIccCallForwardingStatusChange
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TBuf8<1> littleBuf;
customAPI.NotifyIccCallForwardingStatusChange(requestStatus, littleBuf);
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
indiComplete.iIndicator = 0xFF;
iMockLTSY.CompleteL(ECustomNotifyIccCallForwardingStatusChangeIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNICFSC-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyIccCallForwardingStatusChange
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyIccCallForwardingStatusChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyIccCallForwardingStatusChange0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TCFIndicators indi;
RMmCustomAPI::TCFIndicatorsPckg indiPckg(indi);
RMmCustomAPI::TCFIndicators indi2;
RMmCustomAPI::TCFIndicatorsPckg indiPckg2(indi2);
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::NotifyIccCallForwardingStatusChange
//-------------------------------------------------------------------------
customAPI.NotifyIccCallForwardingStatusChange(requestStatus, indiPckg);
customAPI2.NotifyIccCallForwardingStatusChange(requestStatus2, indiPckg2);
RMmCustomAPI::TCFIndicators indiComplete;
RMmCustomAPI::TCFIndicatorsPckg indiCompletePckg(indiComplete);
_LIT(KNumber, "123456789");
indiComplete.iIndicator = 0xFF;
indiComplete.iCFNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;
indiComplete.iCFNumber.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
indiComplete.iCFNumber.iTelNumber = KNumber;
iMockLTSY.CompleteL(ECustomNotifyIccCallForwardingStatusChangeIPC, KErrNone, indiCompletePckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(indiComplete.iIndicator, indi.iIndicator);
ASSERT_EQUALS(indiComplete.iCFNumber.iTypeOfNumber, indi.iCFNumber.iTypeOfNumber);
ASSERT_EQUALS(indiComplete.iCFNumber.iNumberPlan, indi.iCFNumber.iNumberPlan);
ASSERT_EQUALS(0, indi.iCFNumber.iTelNumber.Compare(indiComplete.iCFNumber.iTelNumber));
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_EQUALS(indiComplete.iIndicator, indi2.iIndicator);
ASSERT_EQUALS(indiComplete.iCFNumber.iTypeOfNumber, indi2.iCFNumber.iTypeOfNumber);
ASSERT_EQUALS(indiComplete.iCFNumber.iNumberPlan, indi2.iCFNumber.iNumberPlan);
ASSERT_EQUALS(0, indi2.iCFNumber.iTelNumber.Compare(indiComplete.iCFNumber.iTelNumber));
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(5, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI2-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCellInfo
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetCellInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCellInfo0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TMmCellInfo* cellInfo = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg(*cellInfo);
RMmCustomAPI::TMmCellInfo* cell = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cell);
RMmCustomAPI::TMmCellInfoPckg cellPckg(*cell);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetCellInfoIPC, KErrNotSupported);
customAPI.GetCellInfo(requestStatus, cellInfoPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetCellInfoIPC);
customAPI.GetCellInfo(requestStatus, cellInfoPckg);
iMockLTSY.CompleteL(ECustomGetCellInfoIPC, KErrGeneral, cellPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetCellInfo when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(ECustomGetCellInfoIPC);
customAPI.GetCellInfo(requestStatus, cellInfoPckg);
FillWithRandomData(*cell);
iMockLTSY.CompleteL(ECustomGetCellInfoIPC, KErrNone, cellPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( TComparator<RMmCustomAPI::TMmCellInfo>::IsEqual(*cell, *cellInfo) );
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetCellInfo
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetCellInfoIPC, KErrNone, cellPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI2-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetCellInfo
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetCellInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCellInfo0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetCellInfo
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::TMmCellInfo* cellInfo = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg(*cellInfo);
RMmCustomAPI::TMmCellInfo* cell = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cell);
RMmCustomAPI::TMmCellInfoPckg cellPckg(*cell);
iMockLTSY.ExpectL(ECustomGetCellInfoIPC);
customAPI.GetCellInfo(requestStatus, cellInfoPckg);
customAPI.CancelAsyncRequest(ECustomGetCellInfoIPC);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomGetCellInfoIPC, KErrNone, cellPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI2-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCellInfo with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetCellInfo with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCellInfo0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMmCustomAPI::GetCellInfo
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TBuf8<1> littleBuf;
customAPI.GetCellInfo(requestStatus, littleBuf);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI2-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetCellInfo
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetCellInfo
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCellInfo0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TMmCellInfo* cellInfo = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg(*cellInfo);
RMmCustomAPI::TMmCellInfo* cellInfo2 = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo2);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg2(*cellInfo2);
iMockLTSY.ExpectL(ECustomGetCellInfoIPC);
customAPI.GetCellInfo(requestStatus, cellInfoPckg);
customAPI2.GetCellInfo(requestStatus2, cellInfoPckg2);
RMmCustomAPI::TMmCellInfo* cell = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cell);
RMmCustomAPI::TMmCellInfoPckg cellPckg(*cell);
iMockLTSY.CompleteL(ECustomGetCellInfoIPC, KErrNone, cellPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(8, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGCI2-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetCellInfo with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetCellInfo and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetCellInfo0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TMmCellInfo* cellInfo = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg(*cellInfo);
iMockLTSY.ExpectL(ECustomGetCellInfoIPC);
customAPI.GetCellInfo(requestStatus, cellInfoPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
void CCTsyCustomIPCFU::FillWithRandomData( RMmCustomAPI::TMmCellInfo &aCell, TInt aRnd) const
{
aCell.iMode = RMmCustomAPI::TMmCellInfo::EGSM;
aCell.iGsmCellInfo.iTA = 100;
for( TInt i = 0; i <KMaxNmrAmount; i++ )
{
aCell.iGsmCellInfo.iNmr[i].iARFCN = 3 * i + aRnd;
aCell.iGsmCellInfo.iNmr[i].iBSIC = 3 * i + 1 + aRnd;
aCell.iGsmCellInfo.iNmr[i].iRxLEV = 3 * i + 2 + aRnd;
}
aCell.iWcdmaCellInfo.iFrequencyInfo.iFddUL = 1 + aRnd;
aCell.iWcdmaCellInfo.iFrequencyInfo.iFddDL = 2 + aRnd;
aCell.iWcdmaCellInfo.iFrequencyInfo.iTddNt = 3 + aRnd;
aCell.iWcdmaCellInfo.iPrimaryScrambilingCode = 4 + aRnd;
for( TInt j = 0; j <KMaxNetworkMeasureReports; j++ )
{
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCarrierRSSI = 5 + aRnd;
for( TInt k = 0; k <KMaxCellMeasuredResults; k++ )
{
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iCID = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iFddInfo.iPrimaryCPICH = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iFddInfo.iCpichEcN0 = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iFddInfo.iCpichRscp = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iFddInfo.iPathloss = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iTddInfo.iCellParamID = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iTddInfo.iProposedTGSN = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iTddInfo.iPrimaryCcpchRscp = k + aRnd;
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iTddInfo.iPathloss = k + aRnd;
for( TInt l = 0; l <KMaxTimeSlotIscpAmount; l++ )
{
aCell.iWcdmaCellInfo.iNwkMeasureReport[j].iCellMeasuredResult[k].iTddInfo.iTimeslotISCP[l] = l + aRnd;
}
}
}
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNCIC2-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyCellInfoChange
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyCellInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyCellInfoChange0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI::TMmCellInfo* cell = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cell);
RMmCustomAPI::TMmCellInfoPckg cellPckg(*cell);
// RMmCustomAPI::TMmCellInfo initialization with random data
FillWithRandomData(*cell);
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::NotifyCellInfoChange
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(ECustomNotifyCellInfoChangeIPC, KErrNone, cellPckg);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::TMmCellInfo* cellInfo = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg(*cellInfo);
customAPI.NotifyCellInfoChange(requestStatus, cellInfoPckg);
iMockLTSY.CompleteL(ECustomNotifyCellInfoChangeIPC, KErrGeneral, cellPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::NotifyCellInfoChange when result is not cached.
//-------------------------------------------------------------------------
customAPI.NotifyCellInfoChange(requestStatus, cellInfoPckg);
iMockLTSY.CompleteL(ECustomNotifyCellInfoChangeIPC, KErrNone, cellPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( TComparator<RMmCustomAPI::TMmCellInfo>::IsEqual(*cell, *cellInfo) );
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNCIC2-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::NotifyCellInfoChange
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::NotifyCellInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyCellInfoChange0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::NotifyCellInfoChange
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
RMmCustomAPI::TMmCellInfo* cellInfo = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg(*cellInfo);
customAPI.NotifyCellInfoChange(requestStatus, cellInfoPckg);
customAPI.CancelAsyncRequest(ECustomNotifyCellInfoChangeIPC);
RMmCustomAPI::TMmCellInfo* cell = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cell);
RMmCustomAPI::TMmCellInfoPckg cellPckg(*cell);
iMockLTSY.CompleteL(ECustomNotifyCellInfoChangeIPC, KErrNone, cellPckg, 10);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(4);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNCIC2-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::NotifyCellInfoChange with bad parameter data
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::NotifyCellInfoChange with bad parameter data
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyCellInfoChange0003L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//-------------------------------------------------------------------------
// Test B: Test passing wrong descriptor size to parameter in
// RMmCustomAPI::NotifyCellInfoChange
//-------------------------------------------------------------------------
TRequestStatus requestStatus;
TBuf8<1> littleBuf;
customAPI.NotifyCellInfoChange(requestStatus, littleBuf);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrArgument, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2, this); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCNCIC2-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::NotifyCellInfoChange
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::NotifyCellInfoChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestNotifyCellInfoChange0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TMmCellInfo* cellInfo = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg(*cellInfo);
RMmCustomAPI::TMmCellInfo* cellInfo2 = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cellInfo2);
RMmCustomAPI::TMmCellInfoPckg cellInfoPckg2(*cellInfo2);
customAPI.NotifyCellInfoChange(requestStatus, cellInfoPckg);
customAPI2.NotifyCellInfoChange(requestStatus2, cellInfoPckg2);
RMmCustomAPI::TMmCellInfo* cell = new(ELeave) RMmCustomAPI::TMmCellInfo;
CleanupStack::PushL(cell);
RMmCustomAPI::TMmCellInfoPckg cellPckg(*cell);
FillWithRandomData(*cell);
iMockLTSY.CompleteL(ECustomNotifyCellInfoChangeIPC, KErrNone, cellPckg);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE( TComparator<RMmCustomAPI::TMmCellInfo>::IsEqual(*cell, *cellInfo) );
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus2.Int());
ASSERT_TRUE( TComparator<RMmCustomAPI::TMmCellInfo>::IsEqual(*cell, *cellInfo2) );
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(8, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNB-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetSystemNetworkBand
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetSystemNetworkBand
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkBand0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TBandSelection band;
RMmCustomAPI::TNetworkModeCaps mode;
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetBandSelectionIPC, KErrNotSupported);
customAPI.GetSystemNetworkBand(requestStatus, band, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetBandSelectionIPC);
RMmCustomAPI::TBandSelection compBand = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps compMode = RMmCustomAPI::KCapsNetworkModeGsm;
TMockLtsyData2 <RMmCustomAPI::TBandSelection, RMmCustomAPI::TNetworkModeCaps>
ltsyData(compBand, compMode);
ltsyData.SerialiseL(completeData);
iMockLTSY.CompleteL(ECustomGetBandSelectionIPC, KErrGeneral, completeData);
customAPI.GetSystemNetworkBand(requestStatus, band, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::GetSystemNetworkBand when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetBandSelectionIPC);
iMockLTSY.CompleteL( ECustomGetBandSelectionIPC, KErrNone, completeData);
customAPI.GetSystemNetworkBand(requestStatus, band, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compBand == band);
ASSERT_TRUE(compMode == mode);
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::GetSystemNetworkBand
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetBandSelectionIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this); // customAPI, completeData, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNB-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::GetSystemNetworkBand
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::GetSystemNetworkBand
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkBand0002L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TBandSelection band;
RMmCustomAPI::TNetworkModeCaps mode;
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::GetSystemNetworkBand
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomGetBandSelectionIPC);
RMmCustomAPI::TBandSelection compBand = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps compMode = RMmCustomAPI::KCapsNetworkModeGsm;
TMockLtsyData2 <RMmCustomAPI::TBandSelection, RMmCustomAPI::TNetworkModeCaps>
ltsyData(compBand, compMode);
ltsyData.SerialiseL(completeData);
customAPI.GetSystemNetworkBand(requestStatus, band, mode);
customAPI.CancelAsyncRequest(ECustomGetBandSelectionIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomGetBandSelectionIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3); // customAPI, completeData, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNB-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::GetSystemNetworkBand
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::GetSystemNetworkBand
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkBand0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RBuf8 completeData;
CleanupClosePushL(completeData);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TBandSelection band;
RMmCustomAPI::TNetworkModeCaps mode;
RMmCustomAPI::TBandSelection band2;
RMmCustomAPI::TNetworkModeCaps mode2;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetSystemNetworkBand
//-------------------------------------------------------------------------
RMmCustomAPI::TBandSelection compBand = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps compMode = RMmCustomAPI::KCapsNetworkModeGsm;
TMockLtsyData2 <RMmCustomAPI::TBandSelection, RMmCustomAPI::TNetworkModeCaps>
ltsyData(compBand, compMode);
ltsyData.SerialiseL(completeData);
iMockLTSY.ExpectL( ECustomGetBandSelectionIPC);
iMockLTSY.CompleteL( ECustomGetBandSelectionIPC, KErrNone, completeData, 20);
customAPI.GetSystemNetworkBand(requestStatus, band, mode);
customAPI2.GetSystemNetworkBand(requestStatus2, band2, mode2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_TRUE(compBand == band);
ASSERT_TRUE(compMode == mode);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCGSNB-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetSystemNetworkBand with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetSystemNetworkBand and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetSystemNetworkBand0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TBandSelection band;
RMmCustomAPI::TNetworkModeCaps mode;
iMockLTSY.ExpectL( ECustomGetBandSelectionIPC);
customAPI.GetSystemNetworkBand(requestStatus, band, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2); // customAPI, this
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNB-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetSystemNetworkBand
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetSystemNetworkBand
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkBand0001L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TBandSelection band = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps mode = RMmCustomAPI::KCapsNetworkModeGsm;
TMockLtsyData2 <RMmCustomAPI::TBandSelection, RMmCustomAPI::TNetworkModeCaps>
ltsyData(band, mode);
ltsyData.SerialiseL(data);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetBandSelectionIPC, data, KErrNotSupported);
customAPI.SetSystemNetworkBand(requestStatus, band, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetBandSelectionIPC, data);
iMockLTSY.CompleteL(ECustomSetBandSelectionIPC, KErrGeneral);
customAPI.SetSystemNetworkBand(requestStatus, band, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::SetSystemNetworkBand when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetBandSelectionIPC, data);
iMockLTSY.CompleteL( ECustomSetBandSelectionIPC, KErrNone);
customAPI.SetSystemNetworkBand(requestStatus, band, mode);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::SetSystemNetworkBand
// from LTSY.
//-------------------------------------------------------------------------
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL( ECustomSetBandSelectionIPC, KErrNone);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNB-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMmCustomAPI::SetSystemNetworkBand
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMmCustomAPI::SetSystemNetworkBand
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkBand0002L()
{
//Test works on 9.6 but causes this step and rest of the suite to fail
//ASSERT_TRUE(EFalse);
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TBandSelection band = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps mode = RMmCustomAPI::KCapsNetworkModeGsm;
TMockLtsyData2 <RMmCustomAPI::TBandSelection, RMmCustomAPI::TNetworkModeCaps>
ltsyData(band, mode);
ltsyData.SerialiseL(data);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//-------------------------------------------------------------------------
// Test cancelling of RMmCustomAPI::SetSystemNetworkBand
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetBandSelectionIPC, data);
iMockLTSY.CompleteL( ECustomSetBandSelectionIPC, KErrNone);
customAPI.SetSystemNetworkBand(requestStatus, band, mode);
customAPI.CancelAsyncRequest(ECustomSetBandSelectionIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNB-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMmCustomAPI::SetSystemNetworkBand
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMmCustomAPI::SetSystemNetworkBand
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkBand0004L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
TRequestStatus requestStatus;
TRequestStatus requestStatus2;
RMmCustomAPI::TBandSelection band = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps mode = RMmCustomAPI::KCapsNetworkModeGsm;
TMockLtsyData2 <RMmCustomAPI::TBandSelection, RMmCustomAPI::TNetworkModeCaps>
ltsyData(band, mode);
ltsyData.SerialiseL(data);
RMmCustomAPI::TBandSelection band2 = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps mode2 = RMmCustomAPI::KCapsNetworkModeGsm;
//-------------------------------------------------------------------------
// Test A: Test multiple clients requesting RMmCustomAPI::GetSystemNetworkBand
//-------------------------------------------------------------------------
iMockLTSY.ExpectL( ECustomSetBandSelectionIPC, data);
iMockLTSY.CompleteL( ECustomSetBandSelectionIPC, KErrNone);
customAPI.SetSystemNetworkBand(requestStatus, band, mode);
customAPI2.SetSystemNetworkBand(requestStatus2, band2, mode2);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-MCSSNB-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SetSystemNetworkBand with timeout
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::SetSystemNetworkBand and tests for timeout
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestSetSystemNetworkBand0005L()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
TRequestStatus requestStatus;
RMmCustomAPI::TBandSelection band = RMmCustomAPI::ENetworkBandUmts850;
RMmCustomAPI::TNetworkModeCaps mode = RMmCustomAPI::KCapsNetworkModeGsm;
TMockLtsyData2 <RMmCustomAPI::TBandSelection, RMmCustomAPI::TNetworkModeCaps>
ltsyData(band, mode);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL( ECustomSetBandSelectionIPC, data);
customAPI.SetSystemNetworkBand(requestStatus, band, mode);
ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 407702);
// RMmCustomAPI::SetSystemNetworkBand is not completed by timeout.
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3);
}
/**
@SYMTestCaseID BA-CTSY-CIPC-USS-0001
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::GetUSIMServiceSupport
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetUSIMServiceSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetUSIMServiceSupport0001L()
{
//Setup
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//End Setup
// Start
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
TInt appNum = 68; // fill expected appNumber
TPckg<TInt> appNumPckg(appNum);
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg, KErrNotSupported);
TRequestStatus requestStatus;
RMmCustomAPI::TAppSupport usimSupport;
usimSupport.iAppNum=appNum;
usimSupport.iSupported=ETrue;
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
// Successful call
// Expect and Complete Calls
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg);
RMmCustomAPI::TAppSupport compData;
compData.iAppNum = 68; // fill
compData.iSupported = EFalse; //app is not supported
TPckg<RMmCustomAPI::TAppSupport> compPckg(compData);
iMockLTSY.CompleteL( ECustomGetServiceTableSupportbyApplicationIPC, KErrNone, compPckg);
//Call API
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(68, usimSupport.iAppNum);
ASSERT_TRUE(EFalse == usimSupport.iSupported);
AssertMockLtsyStatusL();
//Not Supported
// Expect and Complete Calls
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg);
iMockLTSY.CompleteL( ECustomGetServiceTableSupportbyApplicationIPC, KErrNotSupported, compPckg);
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
AssertMockLtsyStatusL();
//KErrGeneral
// Expect and Complete Calls
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg);
iMockLTSY.CompleteL( ECustomGetServiceTableSupportbyApplicationIPC, KErrGeneral, compPckg);
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
AssertMockLtsyStatusL();
//End
CleanupStack::PopAndDestroy(2); //this, customAPI
}
/**
@SYMTestCaseID BA-CTSY-CIPC-USS-0002
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancel of RMmCustomAPI::GetUSIMServiceSupport
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetUSIMServiceSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetUSIMServiceSupport0002L()
{
//Setup
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//End Setup
// Start
// Successful call
// Expect and Complete Calls
TInt appNum = 68; // fill expected appNumber
TPckg<TInt> appNumPckg(appNum);
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg);
//Call API
TRequestStatus requestStatus;
RMmCustomAPI::TAppSupport usimSupport;
usimSupport.iAppNum=appNum;
usimSupport.iSupported=ETrue;
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
customAPI.CancelAsyncRequest(ECustomGetServiceTableSupportbyApplicationIPC);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrCancel, requestStatus.Int());
//End
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(2); //this, customAPI
}
/**
@SYMTestCaseID BA-CTSY-CIPC-USS-0003
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test cancel of RMmCustomAPI::GetUSIMServiceSupport
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetUSIMServiceSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetUSIMServiceSupport0003L()
{
//Setup
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//End Setup
// Start
// Pass negative appNum
// Expect and Complete Calls
TInt appNum = -5;
TPckg<TInt> appNumPckg(appNum);
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg);
RMmCustomAPI::TAppSupport compData;
compData.iAppNum = -5; // fill
compData.iSupported = EFalse; //app is not supported
TPckg<RMmCustomAPI::TAppSupport> compPckg(compData);
iMockLTSY.CompleteL( ECustomGetServiceTableSupportbyApplicationIPC, KErrNotFound, compPckg);
//Call API
TRequestStatus requestStatus;
RMmCustomAPI::TAppSupport usimSupport;
usimSupport.iAppNum=-5;
usimSupport.iSupported=ETrue;
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrNotFound, requestStatus.Int());
AssertMockLtsyStatusL();
//End
CleanupStack::PopAndDestroy(2); //this, customAPI
}
/**
@SYMTestCaseID BA-CTSY-CIPC-USS-0004
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test multiple client requests to RMmCustomAPI::GetUSIMServiceSupport
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetUSIMServiceSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetUSIMServiceSupport0004L()
{
//Setup
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
// Open second client
RTelServer telServer2;
TInt ret = telServer2.Connect();
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(telServer2);
RMobilePhone phone2;
ret = phone2.Open(telServer2,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(phone2);
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RMmCustomAPI customAPI2;
OpenCustomAPILC(customAPI2, phone2, EFalse);
//End Setup
// Start
// 1st Client Request
TInt appNum = 68; // fill expected appNumber
TPckg<TInt> appNumPckg(appNum);
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg, KErrNone);
RMmCustomAPI::TAppSupport compData;
compData.iAppNum = 68; // fill
compData.iSupported = ETrue; //app is not supported
TPckg<RMmCustomAPI::TAppSupport> compPckg(compData);
TRequestStatus requestStatus;
RMmCustomAPI::TAppSupport usimSupport;
usimSupport.iAppNum=appNum;
usimSupport.iSupported=EFalse;
iMockLTSY.CompleteL( ECustomGetServiceTableSupportbyApplicationIPC, KErrNone, compPckg);
// 2nd Client Request
TInt appNum2 = 67; // fill expected appNumber
TRequestStatus requestStatus2;
RMmCustomAPI::TAppSupport usimSupport2;
usimSupport2.iAppNum=appNum2;
usimSupport2.iSupported=EFalse;
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
customAPI2.GetUSIMServiceSupport(requestStatus2, usimSupport2);
User::WaitForRequest(requestStatus);
User::WaitForRequest(requestStatus2);
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());
AssertMockLtsyStatusL();
//End
CleanupStack::PopAndDestroy(5); //this, telserver2, phone2, customAPI, customAPI2
}
/**
@SYMTestCaseID BA-CTSY-CIPC-USS-0005
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test timeout for request RMmCustomAPI::GetUSIMServiceSupport
@SYMTestPriority High
@SYMTestActions Invokes RMmCustomAPI::GetUSIMServiceSupport
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCustomIPCFU::TestGetUSIMServiceSupport0005L()
{
//Setup
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
//End Setup
// Start
TInt appNum = 68; // fill expected appNumber
TPckg<TInt> appNumPckg(appNum);
iMockLTSY.ExpectL( ECustomGetServiceTableSupportbyApplicationIPC, appNumPckg, KErrNone);
TRequestStatus requestStatus;
RMmCustomAPI::TAppSupport usimSupport;
usimSupport.iAppNum=appNum;
usimSupport.iSupported=ETrue;
customAPI.GetUSIMServiceSupport(requestStatus, usimSupport);
User::WaitForRequest(requestStatus);
ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
AssertMockLtsyStatusL();
//End
CleanupStack::PopAndDestroy(2); //this, customAPI
}
// Helper methods
void CCTsyCustomIPCFU::OpenCustomAPILC(RMmCustomAPI& aCustomAPI, RMobilePhone& aPhone, TBool aExpectNeeded)
{
RBuf8 data;
CleanupClosePushL(data);
if(aExpectNeeded)
{
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
currentlyRetrievedCache.iCacheId = 1;
currentlyRetrievedCache.iRecordId = 0;
TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyData(currentlyRetrievedCache);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, data);
}
TInt errorCode = aCustomAPI.Open(aPhone);
ASSERT_EQUALS(KErrNone, errorCode);
CleanupStack::PopAndDestroy (&data);
CleanupClosePushL(aCustomAPI);
}
void CCTsyCustomIPCFU::OpenCustomAPILC(RMmCustomAPI& aCustomAPI)
{
OpenCustomAPILC(aCustomAPI,iPhone);
}
void CCTsyCustomIPCFU::OpenLineLC(RLine& aLine, RPhone& aPhone, const TDesC& aName)
{
TInt res = aLine.Open(aPhone, aName);
ASSERT_EQUALS(KErrNone, res);
CleanupClosePushL(aLine);
AssertMockLtsyStatusL();
}
void CCTsyCustomIPCFU::CreateAndOpenIncomingCalLC(RLine &aLine,
RCall &aCall,
TName& aCallName,
const TDesC& aLineName,
const TInt aCallId,
RMobileCall::TMobileCallStatus aMobileCallStatus,
RMobilePhone::TMobileService aMobileService
)
{
TInt ret = CreateIncomingCallL(aLine, aCallId, aLineName, aCallName,
aMobileService, aMobileCallStatus);
ASSERT_EQUALS(KErrNone, ret);
ret = aCall.OpenExistingCall(aLine, aCallName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(aCall);
}
/**
* The purpose of this function is to invoke RMmCustomAPI::Open
* _before_ EMmTsyBootNotifySimStatusReadyIPC CTSY event is triggered and thus
* let the Viag Home Zome Cache to be initialized.
*/
void CCTsyCustomIPCFU::OpenPhoneAndCustomAPILC(RMmCustomAPI& aCustomAPI, TInt aNtsyError)
{
CleanupClosePushL(aCustomAPI);
TInt err = iPhone.Open(iTelServer,KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, err);
err=iMockLTSY.Connect();
ASSERT_EQUALS(KErrNone, err);
RBuf8 data;
data.CleanupClosePushL();
RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
currentlyRetrievedCache.iCacheId = 1;
currentlyRetrievedCache.iRecordId = 0;
TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyData(currentlyRetrievedCache);
// 2-nd & all further EReadViagHomeZoneCacheIPC
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMax; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
MockPrimeEReadViagHomeZoneCacheIPCL(c,r, ETrue, ETrue, aNtsyError);
if(aNtsyError != KErrNone)
{
// got error, send only once
c = KViagHomeZoneCacheIdMax + 1;
r = KViagHomeZoneCacheRecordIdMax + 1;
}
}
}
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//************************************************************
//* Invoke RMmCustomAPI::Open prior to triggering any further
//* CTSY events including EMmTsyBootNotifySimStatusReadyIPC
//************************************************************
err = aCustomAPI.Open(iPhone);
ASSERT_EQUALS(KErrNone, err);
// EMmTsyBootNotifyModemStatusReadyIPC
iMockLTSY.CompleteL(EMmTsyBootNotifyModemStatusReadyIPC,KErrNone);
// EMobilePhoneGetNetworkRegistrationStatus
iMockLTSY.ExpectL(EMobilePhoneGetNetworkRegistrationStatus);
iMockLTSY.CompleteL(EMobilePhoneGetNetworkRegistrationStatus,KErrNone,0);
// EMmTsyBootNotifySimStatusReadyIPC
iMockLTSY.ExpectL(EMmTsyBootNotifySimStatusReadyIPC);
iMockLTSY.CompleteL(EMmTsyBootNotifySimStatusReadyIPC,KErrNone,0);
// EMobilePhoneGetHomeNetwork
RMobilePhone::TMobilePhoneNetworkInfoV5 homeNetwork;
homeNetwork.iMode = RMobilePhone::ENetworkModeWcdma;
homeNetwork.iStatus = RMobilePhone::ENetworkStatusCurrent;
homeNetwork.iBandInfo = RMobilePhone::EBandUnknown;
homeNetwork.iCountryCode = _L("234");
homeNetwork.iCdmaSID = _L("");
homeNetwork.iAnalogSID = _L("");
homeNetwork.iNetworkId = _L("23499");
homeNetwork.iDisplayTag = _L("symbian");
homeNetwork.iShortName = _L("symbian");
homeNetwork.iLongName = _L("symbian mobile");
homeNetwork.iAccess = RMobilePhone::ENetworkAccessUtran;
homeNetwork.iEgprsAvailableIndicator = ETrue;
homeNetwork.iHsdpaAvailableIndicator = ETrue;
TMockLtsyData1<RMobilePhone::TMobilePhoneNetworkInfoV5> homeNetworkData(homeNetwork);
homeNetworkData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetHomeNetwork);
iMockLTSY.CompleteL(EMobilePhoneGetHomeNetwork,KErrNone,data,0);
// EMmTsyPhoneGetPin1DisableSupportedIPC
TBool pin1DisableSupport = ETrue;
TMockLtsyData1<TBool> pin1DisableSupportData(pin1DisableSupport);
data.Close();
pin1DisableSupportData.SerialiseL(data);
iMockLTSY.ExpectL(EMmTsyPhoneGetPin1DisableSupportedIPC);
iMockLTSY.CompleteL(EMmTsyPhoneGetPin1DisableSupportedIPC,KErrNone,data,0);
// EMmTsySimRefreshRegisterIPC
iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);
// EMobilePhoneGetServiceTable
RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::ESIMServiceTable;
TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTable> serviceTableData(serviceTable);
data.Close();
serviceTableData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetServiceTable, 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<RMobilePhone::TMobilePhoneServiceTableV1> serviceTableResultData(serviceTableResult);
data.Close();
serviceTableResultData.SerialiseL(data);
iMockLTSY.CompleteL(EMobilePhoneGetServiceTable,KErrNone,data,0);
// EMobilePhoneGetALSLine
RMobilePhone::TMobilePhoneALSLine alsLine = RMobilePhone::EAlternateLinePrimary;
TMockLtsyData1<RMobilePhone::TMobilePhoneALSLine> alsLineData(alsLine);
data.Close();
alsLineData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetALSLine);
iMockLTSY.CompleteL(EMobilePhoneGetALSLine,KErrNone,data,0);
// ECustomGetIccCallForwardingStatusIPC
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
// EMobilePhoneGetIccMessageWaitingIndicators
RMobilePhone::TMobilePhoneMessageWaitingV1 expectedMessageIndicators;
TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1>
indicatorsData(expectedMessageIndicators);
data.Close();
indicatorsData.SerialiseL(data);
iMockLTSY.ExpectL(EMobilePhoneGetIccMessageWaitingIndicators);
iMockLTSY.CompleteL(EMobilePhoneGetIccMessageWaitingIndicators, KErrNone, data);
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.ExpectL(EMobilePhoneGetCustomerServiceProfile);
// 2-nd & all further EReadViagHomeZoneCacheIPC
for(TInt c = KViagHomeZoneCacheIdMin; c <= KViagHomeZoneCacheIdMax; c++)
{
for(TInt r = KViagHomeZoneCacheRecordIdMin; r <= KViagHomeZoneCacheRecordIdMax; r++)
{
MockPrimeEReadViagHomeZoneCacheIPCL(c,r, ETrue, ETrue, aNtsyError);
if(aNtsyError != KErrNone)
{
// got error, send only once
c = KViagHomeZoneCacheIdMax + 1;
r = KViagHomeZoneCacheRecordIdMax + 1;
}
}
}
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(1,&data);
}
void CCTsyCustomIPCFU::MockPrimeEReadViagHomeZoneCacheIPCL(TInt aCacheId,TInt aRecordId,TBool aDoComplete, TBool aDoExpect, TInt aNtsyError)
{
RBuf8 data;
data.CleanupClosePushL();
RMmCustomAPI::TViagCacheRecordId id;
id.iCacheId = aCacheId;
id.iRecordId = aRecordId;
if(aDoExpect)
{
TMockLtsyData1<RMmCustomAPI::TViagCacheRecordId> idData(id);
idData.SerialiseL(data);
iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC,data);
}
if(aDoComplete)
{
RMmCustomAPI::TViagCacheRecordContent& content =
iViagHomeZoneCache[aCacheId - KViagHomeZoneCacheIdMin][aRecordId - KViagHomeZoneCacheRecordIdMin];
content.iCellId = 1000 + aCacheId;
content.iLac =2000 + aRecordId;
TMockLtsyData1<RMmCustomAPI::TViagCacheRecordContent> contentData(content);
data.Close();
contentData.SerialiseL(data);
iMockLTSY.CompleteL(EReadViagHomeZoneCacheIPC,aNtsyError,data,0);
}
CleanupStack::PopAndDestroy(1,&data);
}
void CCTsyCustomIPCFU::AuxReadViagHomeZoneParamsL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
RMmCustomAPI customAPI;
OpenCustomAPILC(customAPI, iPhone);
RBuf8 completeData;
CleanupClosePushL(completeData);
TRequestStatus requestStatus;
TRequestStatus mockLtsyStatus;
RMmCustomAPI::TViagElement element;
_LIT(KScp, "Lenin lives!");
_LIT(KSmsC, "revolution");
// Variables for call ReadViagHomeZoneParams.
RMmCustomAPI::TViagParams param;
RMmCustomAPI::TViagElements* elems = NULL;
elems = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(elems);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
elems->AppendL(element);
}
// Variables for call CompleteL.
RMmCustomAPI::TViagParams completeParam;
completeParam.iScp = KScp;
completeParam.iSmsC = KSmsC;
completeParam.iSubscribedZoneAndVersion = 17;
RMmCustomAPI::TViagElements* completeElems;
FillWithRandomDataLC(completeElems);
TMockLtsyData2<RMmCustomAPI::TViagParams, RMmCustomAPI::TViagElements*>
mockData2(completeParam, completeElems);
//-------------------------------------------------------------------------
// TEST A: failure to dispatch request to LTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EReadViagHomeZoneParamsIPC, KErrNotSupported);
customAPI.ReadViagHomeZoneParams(requestStatus, param, *elems);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST B: failure on completion of pending request from LTSY->CTSY
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EReadViagHomeZoneParamsIPC);
mockData2.SerialiseL(completeData);
iMockLTSY.CompleteL(EReadViagHomeZoneParamsIPC, KErrGeneral, completeData);
customAPI.ReadViagHomeZoneParams(requestStatus, param, *elems);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrGeneral, requestStatus.Int());
//-------------------------------------------------------------------------
// TEST C: Successful completion request of
// RMmCustomAPI::ReadViagHomeZoneParams when result is not cached.
//-------------------------------------------------------------------------
iMockLTSY.ExpectL(EReadViagHomeZoneParamsIPC);
iMockLTSY.CompleteL(EReadViagHomeZoneParamsIPC, KErrNone, completeData);
customAPI.ReadViagHomeZoneParams(requestStatus, param, *elems);
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, completeParam.iScp.Compare(param.iScp));
ASSERT_EQUALS(0, completeParam.iSmsC.Compare(param.iSmsC));
ASSERT_EQUALS(completeParam.iSubscribedZoneAndVersion, param.iSubscribedZoneAndVersion);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
ASSERT_EQUALS(completeElems->At(i).iActiveFlag , elems->At(i).iActiveFlag );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iR2 , elems->At(i).iCoordinates.iR2 );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iX , elems->At(i).iCoordinates.iX );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iY , elems->At(i).iCoordinates.iY );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iZoneId, elems->At(i).iCoordinates.iZoneId);
ASSERT_EQUALS(0, completeElems->At(i).iName.Compare(elems->At(i).iName));
}
//-------------------------------------------------------------------------
// TEST E: Unsolicited completion of RMmCustomAPI::ReadViagHomeZoneParams
// from LTSY.
//-------------------------------------------------------------------------
iMockLTSY.NotifyTerminated(mockLtsyStatus);
iMockLTSY.CompleteL(EReadViagHomeZoneParamsIPC, KErrNone, completeData);
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
CleanupStack::PopAndDestroy(5, this);
}
void CCTsyCustomIPCFU::AuxReadViagHomeZoneParamsForIncreasingCoverageL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
TInt err = iPhone.Open(iTelServer, KMmTsyPhoneName);
ASSERT_EQUALS(KErrNone, err);
err=iMockLTSY.Connect();
ASSERT_EQUALS(KErrNone, err);
RBuf8 data;
CleanupClosePushL(data);
RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
currentlyRetrievedCache.iCacheId = 1;
currentlyRetrievedCache.iRecordId = 0;
TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyData(currentlyRetrievedCache);
ltsyData.SerialiseL(data);
iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, data);
RMmCustomAPI customAPI;
TInt errorCode = customAPI.Open(iPhone);
ASSERT_EQUALS(KErrNone, errorCode);
CleanupStack::PopAndDestroy (&data);
CleanupClosePushL(customAPI);
RBuf8 completeData;
CleanupClosePushL(completeData);
RBuf8 expectData;
CleanupClosePushL(expectData);
TRequestStatus requestStatus;
RMmCustomAPI::TViagElement element;
_LIT(KScp, "Lenin lives!");
_LIT(KSmsC, "revolution");
// Variables for call ReadViagHomeZoneParams.
RMmCustomAPI::TViagParams param;
RMmCustomAPI::TViagElements* elems = NULL;
elems = new (ELeave) RMmCustomAPI::TViagElements( RMmCustomAPI::KViagElementCount );
CleanupStack::PushL(elems);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
elems->AppendL(element);
}
// Variables for call CompleteL.
RMmCustomAPI::TViagParams completeParam;
completeParam.iScp = KScp;
completeParam.iSmsC = KSmsC;
completeParam.iSubscribedZoneAndVersion = 17;
RMmCustomAPI::TViagElements* completeElems;
FillWithRandomDataLC(completeElems);
TMockLtsyData2<RMmCustomAPI::TViagParams, RMmCustomAPI::TViagElements*>
mockData2(completeParam, completeElems);
//-------------------------------------------------------------------------
customAPI.ReadViagHomeZoneParams(requestStatus, param, *elems);
//-------------------------------------------------------------------------
// There are preparations for call of function CheckViagHomezoneParamsL().
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
// EMobilePhoneGetNetworkRegistrationStatus
iMockLTSY.CompleteL(EMmTsyBootNotifySimStatusReadyIPC,KErrNone,0);
// EMobilePhoneGetHomeNetwork
iMockLTSY.ExpectL(EMobilePhoneGetHomeNetwork);
RMobilePhone::TMobilePhoneNetworkInfoV5 homeNetwork;
homeNetwork.iMode = RMobilePhone::ENetworkModeWcdma;
homeNetwork.iStatus = RMobilePhone::ENetworkStatusCurrent;
homeNetwork.iBandInfo = RMobilePhone::EBandUnknown;
homeNetwork.iCountryCode = _L("234");
homeNetwork.iCdmaSID = _L("");
homeNetwork.iAnalogSID = _L("");
homeNetwork.iNetworkId = _L("23499");
homeNetwork.iDisplayTag = _L("symbian");
homeNetwork.iShortName = _L("symbian");
homeNetwork.iLongName = _L("symbian mobile");
homeNetwork.iAccess = RMobilePhone::ENetworkAccessUtran;
homeNetwork.iEgprsAvailableIndicator = ETrue;
homeNetwork.iHsdpaAvailableIndicator = ETrue;
TMockLtsyData1<RMobilePhone::TMobilePhoneNetworkInfoV5> homeNetworkData(homeNetwork);
completeData.Close();
homeNetworkData.SerialiseL(completeData);
iMockLTSY.CompleteL(EMobilePhoneGetHomeNetwork,KErrNone,completeData,0);
// EMmTsyPhoneGetPin1DisableSupportedIPC
iMockLTSY.ExpectL(EMmTsyPhoneGetPin1DisableSupportedIPC);
TBool pin1DisableSupport = ETrue;
TMockLtsyData1<TBool> pin1DisableSupportData(pin1DisableSupport);
completeData.Close();
pin1DisableSupportData.SerialiseL(completeData);
iMockLTSY.CompleteL(EMmTsyPhoneGetPin1DisableSupportedIPC,KErrNone,completeData,0);
// EMmTsySimRefreshRegisterIPC
iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);
// EMobilePhoneGetServiceTable
RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::ESIMServiceTable;
TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTable> serviceTableData(serviceTable);
expectData.Close();
serviceTableData.SerialiseL(expectData);
iMockLTSY.ExpectL(EMobilePhoneGetServiceTable, expectData);
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<RMobilePhone::TMobilePhoneServiceTableV1> serviceTableResultData(serviceTableResult);
completeData.Close();
serviceTableResultData.SerialiseL(completeData);
iMockLTSY.CompleteL(EMobilePhoneGetServiceTable,KErrNone,completeData,0);
// EMobilePhoneGetALSLine
iMockLTSY.ExpectL(EMobilePhoneGetALSLine);
RMobilePhone::TMobilePhoneALSLine alsLine = RMobilePhone::EAlternateLinePrimary;
TMockLtsyData1<RMobilePhone::TMobilePhoneALSLine> alsLineData(alsLine);
completeData.Close();
alsLineData.SerialiseL(completeData);
iMockLTSY.CompleteL(EMobilePhoneGetALSLine,KErrNone,completeData,0);
// ECustomGetIccCallForwardingStatusIPC
iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
// EMobilePhoneGetIccMessageWaitingIndicators
iMockLTSY.ExpectL(EMobilePhoneGetIccMessageWaitingIndicators);
RMobilePhone::TMobilePhoneMessageWaitingV1 expectedMessageIndicators;
TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1>
indicatorsData(expectedMessageIndicators);
completeData.Close();
indicatorsData.SerialiseL(completeData);
iMockLTSY.CompleteL(EMobilePhoneGetIccMessageWaitingIndicators, KErrNone, completeData);
// EReadViagHomeZoneParamsIPC
completeData.Close();
mockData2.SerialiseL(completeData);
iMockLTSY.CompleteL(EReadViagHomeZoneParamsIPC, KErrNone, completeData);
iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
iMockLTSY.ExpectL(EMobilePhoneGetCustomerServiceProfile);
iMockLTSY.ExpectL(EReadViagHomeZoneParamsIPC);
// N.B. EReadViagHomeZoneParamsIPC is not expected at this point because there is an ongoing caching started by customAPI.Open() above.
User::WaitForRequest(mockLtsyStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
//-------------------------------------------------------------------------
User::WaitForRequest(requestStatus);
AssertMockLtsyStatusL();
ASSERT_EQUALS(KErrNone, requestStatus.Int());
ASSERT_EQUALS(0, completeParam.iScp.Compare(param.iScp));
ASSERT_EQUALS(0, completeParam.iSmsC.Compare(param.iSmsC));
ASSERT_EQUALS(completeParam.iSubscribedZoneAndVersion, param.iSubscribedZoneAndVersion);
for (TInt i = 0; i < RMmCustomAPI::KViagElementCount; i++)
{
ASSERT_EQUALS(completeElems->At(i).iActiveFlag , elems->At(i).iActiveFlag );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iR2 , elems->At(i).iCoordinates.iR2 );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iX , elems->At(i).iCoordinates.iX );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iY , elems->At(i).iCoordinates.iY );
ASSERT_EQUALS(completeElems->At(i).iCoordinates.iZoneId, elems->At(i).iCoordinates.iZoneId);
ASSERT_EQUALS(0, completeElems->At(i).iName.Compare(elems->At(i).iName));
}
CleanupStack::PopAndDestroy(6, this);
}
void CCTsyCustomIPCFU::OpenPhoneBookStoreWithSIMRefreshL(RMobilePhoneBookStore &aStore, TName &aName, RMobilePhone &aPhone, TInt aSimError)
{
RBuf8 data;
CleanupClosePushL(data);
RBuf8 data2;
CleanupClosePushL(data2);
TRequestStatus mockLtsyStatus;
iMockLTSY.NotifyTerminated(mockLtsyStatus);
//EMmTsyPhoneBookStoreInitIPC
TMockLtsyPhoneBookData0 storeInitData(aName);
storeInitData.SerialiseL(data);
iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);
_LIT8(KImsi,"01234567890123");
TUint16 files = 2;
TPckg<TUint16> filesData(files);
iMockLTSY.CompleteL(EMmTsySimRefreshNowIPC, aSimError, filesData);
iMockLTSY.ExpectL(EMobilePhoneGetSubscriberId);
iMockLTSY.CompleteL(EMobilePhoneGetSubscriberId, KErrNone, KImsi);
CStorageInfoData storageData;
SetStorageInfoData(storageData);
TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(aName, storageData);
retStoreInitC.SerialiseL(data2);
iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
//EMmTsyPhoneBookStoreCacheIPC
CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
CleanupStack::PushL(cache);
TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(aName, cache);
data2.Close();
storeCacheData.SerialiseL(data2);
data.Close();
storeInitData.SerialiseL(data);
iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, data);
iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, aSimError, data2, 0);
//Open
TInt ret = aStore.Open(aPhone, aName);
ASSERT_EQUALS(KErrNone, ret);
User::WaitForRequest(mockLtsyStatus);
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3); //data, data2, cache
}
void CCTsyCustomIPCFU::FillRandom(TDes8 &aBuff)
{
TUint length = aBuff.MaxLength();
aBuff.SetLength(0);
for (TUint i = 0; i < length; ++i)
{
TUint8 rand = (TUint8) Math::Random();
aBuff.Append(rand);
}
}