diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsyphonefunegative.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsyphonefunegative.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,986 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + + + +/** + @file The TEFUnit test suite for CallControl in the Common TSY. +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include "config.h" +#include "listretrieverao.h" +#include +#include +#include +#include +#include "mockltsyindicatorids.h" +#include "cctsyphonefunegative.h" + +CTestSuite* CCTsyPhoneFUNegative::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0001L); + + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0007L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0008L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0009L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0010L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0011L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0012L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0013L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0014L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0015L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0016L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0017L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0018L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0019L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0020L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0021L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0022L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0023L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0024L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0025L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0026L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0027L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0028L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0029L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0030L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhoneFUNegative, TestUnit0031L); + + END_SUITE; + } +// +// 'Negative' unit tests +// + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneGetFdnStatus is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetFdnStatus() (Sync and Async) +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0001L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetFdnStatus::KLtsyDispatchPhoneGetFdnStatusApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMobilePhone::TMobilePhoneFdnStatus fdnStatus; + + iPhone.GetFdnStatus(requestStatus, fdnStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + TInt err = iPhone.GetFdnStatus(fdnStatus); + ASSERT_EQUALS(KErrNotSupported, err); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(this); // this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomNetWakeupIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::NetWakeup() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0007L() + { + // + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneNspsWakeup::KLtsyDispatchPhoneNspsWakeupApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + customApi.NetWakeup(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomSetSystemNetworkModeIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::SetSystemNetworkMode() (Sync and Async) +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0008L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSetSystemNetworkMode::KLtsyDispatchPhoneSetSystemNetworkModeApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMmCustomAPI::TNetworkModeCaps mode = RMmCustomAPI::KCapsNetworkModeUmts; + + // Check sync version of the API + TInt err = customApi.SetSystemNetworkMode(mode); + ASSERT_EQUALS(KErrNotSupported, err); + + // Check async version of the API + customApi.SetSystemNetworkMode(requestStatus, mode); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomGetCurrentSystemNetworkModesIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::GetCurrentSystemNetworkModes() (Sync and Async) +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0009L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetCurrentSystemNetworkModes::KLtsyDispatchPhoneGetCurrentSystemNetworkModesApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TUint32 modes; + + // Check sync version of the API + TInt err = customApi.GetCurrentSystemNetworkModes(modes); + ASSERT_EQUALS(KErrNotSupported, err); + + // Check async version of the API + customApi.GetCurrentSystemNetworkModes(requestStatus, modes); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomResetNetServerIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::ResetNetServer() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0010L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneResetNetServer::KLtsyDispatchPhoneResetNetServerApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + customApi.ResetNetServer(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomSetAlwaysOnMode is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::SetAlwaysOn() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0011L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSetAlwaysOnMode::KLtsyDispatchPhoneSetAlwaysOnModeApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + // Open a packet service, ctsy must have a packet service sub session in order to activate the SetAlwaysOn + RPacketService packetService; + OpenPacketServiceLC(packetService,RPacketService::EStatusUnattached); + + RMmCustomAPI::TSetAlwaysOnMode expData = RMmCustomAPI::EAlwaysModeBoth; + + customApi.SetAlwaysOn(requestStatus, expData); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(3, this); // customApi, packetService, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0012 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomSetDriveModeIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::SetDriveMode() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0012L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSetDriveMode::KLtsyDispatchPhoneSetDriveModeApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + customApi.SetDriveMode(requestStatus, RMmCustomAPI::EActivateDriveMode); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0013 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomReadHSxPAStatusIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::ReadHSxPAStatus() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0013L() + { + + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetHspaStatus::KLtsyDispatchPhoneGetHspaStatusApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMmCustomAPI::THSxPAStatus hspaStatus; + + customApi.ReadHSxPAStatus(requestStatus, hspaStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0014 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomWriteHSxPAStatusIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::WriteHSxPAStatus() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0014L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSetHspaStatus::KLtsyDispatchPhoneSetHspaStatusApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMmCustomAPI::THSxPAStatus hspaStatus = RMmCustomAPI::EHSxPAEnabled; + + customApi.WriteHSxPAStatus(requestStatus, hspaStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0015 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomGetNetworkProviderNameIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::GetNetworkProviderName() (Sync and Async) +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0015L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetNetworkProviderName::KLtsyDispatchPhoneGetNetworkProviderNameApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhone::TMobilePhoneNetworkLongName name; + + // Check sync version of the API + TInt err = customApi.GetNetworkProviderName(name); + ASSERT_EQUALS(KErrNotSupported, err); + + // Check async version of the API + customApi.GetNetworkProviderName(requestStatus, name); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0016 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomGetOperatorNameIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::GetOperatorName() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0016L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetOperatorName::KLtsyDispatchPhoneGetOperatorNameApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMmCustomAPI::TOperatorNameInfo getNameInfo; + + customApi.GetOperatorName(requestStatus, getNameInfo); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0017 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomGetCellInfoIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes customApi::GetCellInfo() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0017L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetCellInfo::KLtsyDispatchPhoneGetCellInfoApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMmCustomAPI::TMmCellInfo* getInfo = new(ELeave) RMmCustomAPI::TMmCellInfo; + CleanupStack::PushL(getInfo); + RMmCustomAPI::TMmCellInfoPckg *getInfoPckg = new(ELeave) RMmCustomAPI::TMmCellInfoPckg(*getInfo); + CleanupStack::PushL(getInfoPckg); + + customApi.GetCellInfo(requestStatus, *getInfoPckg); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(4, this); //getInfoPckg, getInfo, customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0018 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECtsyPhoneTerminateAllCallsReq is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0018L() + { + // + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneTerminateAllCalls::KLtsyDispatchPhoneTerminateAllCallsApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + DriverDialCallL(callId, mobileService); + + RMobileLine mobileLine; + CleanupClosePushL(mobileLine); + + RMobileCall mobileCall; + CleanupClosePushL(mobileCall); + + ClientDialCallL(mobileLine, mobileCall, mobileService); + + TRequestStatus requestStatus; + + iPhone.TerminateAllCalls(requestStatus); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up + DriverHangUpCallL(callId, hangUpCause, ETrue); + + TRequestStatus reqStatusTerminated; + iMockLTSY.NotifyTerminated(reqStatusTerminated); + + ClientHangUpCallL(mobileCall); + + User::WaitForRequest(reqStatusTerminated); + ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int()); + + mobileCall.Close(); + mobileLine.Close(); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(3, this); // mobileCall, mobileLine, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0019 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneGetServiceProviderName is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetServiceProviderName() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0019L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetServiceProviderName::KLtsyDispatchPhoneGetServiceProviderNameApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMobilePhone::TMobilePhoneServiceProviderNameV2 spn; + RMobilePhone::TMobilePhoneServiceProviderNameV2Pckg spnPkg(spn); + + iPhone.GetServiceProviderName(requestStatus, spnPkg); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(this); // this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0020 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneGetPhoneId is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetPhoneId() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0020L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMobilePhone::TMobilePhoneIdentityV1 id; + + iPhone.GetPhoneId(requestStatus, id); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(this); // this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0021 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneGetDetectedNetworksV2Phase1 is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RetrieveMobilePhoneDetectedNetworks::StartV2() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0021L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetDetectedNetworks::KLtsyDispatchPhoneGetDetectedNetworksApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + CGetDetectedNetworksAO* detAO = CGetDetectedNetworksAO::NewLC(iPhone,iMockLTSY); + + detAO->TestRetrieveNegativeL(); + ASSERT_EQUALS(KErrNotSupported, detAO->iStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // detAO, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0022 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneGetDetectedNetworksCancel is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes CGetDetectedNetworksAO::Cancel() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0022L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetDetectedNetworksCancel::KLtsyDispatchPhoneGetDetectedNetworksCancelApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + CGetDetectedNetworksAO* detAO = CGetDetectedNetworksAO::NewLC(iPhone,iMockLTSY); + + iMockLTSY.ExpectL(MLtsyDispatchPhoneGetDetectedNetworks::KLtsyDispatchPhoneGetDetectedNetworksApiId, KErrNone); + + detAO->TestCancel(); + ASSERT_EQUALS(KErrCancel, detAO->iStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(detAO); + CleanupStack::PopAndDestroy(this); // , this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0023 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneSelectNetwork is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::SelectNetwork() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0023L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSelectNetwork::KLtsyDispatchPhoneSelectNetworkApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMobilePhone::TMobilePhoneNetworkManualSelection selection; + TBool isManual = ETrue; + + iPhone.SelectNetwork(requestStatus,isManual,selection); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(this); // this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0024 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneSelectNetworkCancel is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::CancelAsyncRequest() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0024L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSelectNetworkCancel::KLtsyDispatchPhoneSelectNetworkCancelApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + //setup ETel required data + _LIT(KCountryCode, "1234"); + _LIT(KNetworkId, "12345678"); + + RMobilePhone::TMobilePhoneNetworkManualSelection selection; + selection.iCountry = KCountryCode; + selection.iNetwork = KNetworkId; + + TBool isManual = ETrue; + + TMockLtsyData2 selectData(isManual,selection); + + selectData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchPhoneSelectNetwork::KLtsyDispatchPhoneSelectNetworkApiId, data, KErrNone); + + TRequestStatus requestStatus; + iPhone.SelectNetwork(requestStatus,isManual,selection); + + iPhone.CancelAsyncRequest(EMobilePhoneSelectNetwork); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0025 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneSetNetworkSelectionSetting is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::SetNetworkSelectionSetting() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0025L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSetNetworkSelectionSetting::KLtsyDispatchPhoneSetNetworkSelectionSettingApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMobilePhone::TMobilePhoneNetworkSelectionV1 phoneNetworkSelection; + phoneNetworkSelection.iMethod = RMobilePhone::ENetworkSelectionManual; + phoneNetworkSelection.iBandClass = RMobilePhone::ENetworkBandClassAOnly; + phoneNetworkSelection.iOperationMode = RMobilePhone::ENetworkOperationAnalogPreferred; + RMobilePhone::TMobilePhoneNetworkSelectionV1Pckg setPckg(phoneNetworkSelection); + + iPhone.SetNetworkSelectionSetting(requestStatus,setPckg); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(this); // this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0026 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECtsyPhoneCellInfoIndReq is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetCellInfo() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0026L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneRegisterCellInfoChangeNotification::KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + RMobilePhone::TMobilePhoneNetworkManualSelection selection; + + RMobilePhone::TMobilePhoneCellInfoV9 cellInfo; + RMobilePhone::TMobilePhoneCellInfoV9Pckg cellInfoPckg(cellInfo); + + iPhone.GetCellInfo(requestStatus,cellInfoPckg); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(this); // this + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0027 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECtsyPhoneCellInfoReq is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::GetCellInfo() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0027L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetPhoneCellInfo::KLtsyDispatchPhoneGetPhoneCellInfoApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + iMockLTSY.ExpectL(MLtsyDispatchPhoneRegisterCellInfoChangeNotification::KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId); + + TRequestStatus getCellInfoReqStatus; + RMobilePhone::TMobilePhoneCellInfoV9 cellInfo2; + RMobilePhone::TMobilePhoneCellInfoV9Pckg cellInfoPckg2(cellInfo2); + + // iLtsyDispatchPhoneGetPhoneCellInfo not NULL when disabling the IPC + iPhone.GetCellInfo(getCellInfoReqStatus,cellInfoPckg2); + + User::WaitForRequest(getCellInfoReqStatus); + ASSERT_EQUALS(getCellInfoReqStatus.Int(),KErrNotSupported); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); // this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0028 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomGetServiceTableSupportbyApplicationIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::GetUSIMServiceSupport() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0028L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetUsimServiceSupport::KLtsyDispatchPhoneGetUsimServiceSupportApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus requestStatus; + RMmCustomAPI::TAppSupport usimSupport; + + customApi.GetUSIMServiceSupport(requestStatus, usimSupport); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0029 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if EMobilePhoneGetCurrentActiveUSimApplication is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::GetCurrentActiveUSimApplication() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0029L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetCurrentActiveUsimApplication::KLtsyDispatchPhoneGetCurrentActiveUsimApplicationApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus requestStatus; + RMobilePhone::TAID aid; + + iPhone.GetCurrentActiveUSimApplication(requestStatus, aid); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0030 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomGetBandSelectionIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::GetSystemNetworkBand() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0030L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneGetSystemNetworkBand::KLtsyDispatchPhoneGetSystemNetworkBandApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus requestStatus; + RMmCustomAPI::TBandSelection band; + RMmCustomAPI::TNetworkModeCaps mode; + + customApi.GetSystemNetworkBand(requestStatus, band, mode); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONE-NEGATIVE-UN0031 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test returned value if ECustomSetBandSelectionIPC is not supported by LTSY +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::SetSystemNetworkBand() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhoneFUNegative::TestUnit0031L() + { + TConfig config; + config.SetSupportedValue(MLtsyDispatchPhoneSetSystemNetworkBand::KLtsyDispatchPhoneSetSystemNetworkBandApiId, EFalse); + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup, this)); + OpenPhoneL(); + + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus requestStatus; + RMmCustomAPI::TBandSelection band=RMmCustomAPI::ENetworkBandAny; + RMmCustomAPI::TNetworkModeCaps mode=RMmCustomAPI::KCapsNetworkModeUmts; + + customApi.SetSystemNetworkBand(requestStatus, band, mode); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported); + + AssertMockLtsyStatusL(); + config.Reset(); + CleanupStack::PopAndDestroy(2, this); // customApi, this + }