* Copyright (C) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define private public
#define protected public
#include "cellular_call_config.h"
#include "cellular_call_connection_ims.h"
#include "cellular_call_handler.h"
#include "cellular_call_proxy.h"
#include "cellular_call_register.h"
#include "cellular_call_service.h"
#include "cellular_call_supplement.h"
#include "config_request.h"
#include "control_base.h"
#include "cs_control.h"
#include "gtest/gtest.h"
#include "tel_ril_call_parcel.h"
#include "ims_call_callback_proxy.h"
#include "ims_call_callback_stub.h"
#include "ims_call_client.h"
#include "ims_control.h"
#include "ims_error.h"
#include "token.h"
#include "securec.h"
#include "cellular_call_hisysevent.h"
#include "standardize_utils.h"
#include "cellular_call_rdb_helper.h"
#include "cellular_call_dump_helper.h"
#include "emergency_utils.h"
#include "satellite_call_client.h"
#include "telephony_ext_wrapper.h"
#include "mock_sim_manager.h"
#include "gmock/gmock.h"
namespace OHOS {
namespace Telephony {
using namespace testing;
using namespace testing::ext;
#ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
static const int32_t INVALID_VALUE = -1;
#endif
namespace {
const int32_t INVALID_SLOTID = 2;
const int32_t SIM1_SLOTID = 0;
const int32_t SIM2_SLOTID = 1;
const int32_t ACTIVATE_ACTION = 1;
const std::string PHONE_NUMBER = "00000000";
const int32_t DEFAULT_INDEX = 1;
const int32_t FIVE_MINUTES = 5;
}
class DemoHandler : public AppExecFwk::EventHandler {
public:
explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &runner) : AppExecFwk::EventHandler(runner) {}
virtual ~DemoHandler() {}
void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
};
class ZeroBranch1Test : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
int32_t InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo);
void InitImsCallInfoList(ImsCurrentCallList &callInfoList, int32_t num);
void InitCsCallInfoList(CallInfoList &callInfoList, int32_t num);
void MakeCallInfoParcelData(bool isError, MessageParcel &data);
MockSimManager *mockSimManager = new MockSimManager();
};
void ZeroBranch1Test::SetUpTestCase()
{
std::cout << "---------- CellularCallService start ------------" << std::endl;
DelayedSingleton<CellularCallService>::GetInstance()->Init();
DelayedSingleton<ImsCallClient>::GetInstance()->Init();
}
void ZeroBranch1Test::TearDownTestCase() {}
void ZeroBranch1Test::SetUp() {}
void ZeroBranch1Test::TearDown()
{
std::this_thread::sleep_for(std::chrono::seconds(FIVE_MINUTES));
}
bool IsMmiCodeMockTrue(int32_t slotId, std::string &number)
{
return true;
}
bool IsMmiCodeMockFalse(int32_t slotId, std::string &number)
{
return false;
}
int32_t ZeroBranch1Test::InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo)
{
callInfo.accountId = accountId;
callInfo.slotId = accountId;
callInfo.index = accountId;
callInfo.callType = CallType::TYPE_IMS;
callInfo.videoState = 0;
if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
return TELEPHONY_ERR_MEMSET_FAIL;
}
if (phonenumber.length() > static_cast<size_t>(kMaxNumberLen)) {
return CALL_ERR_NUMBER_OUT_OF_RANGE;
}
if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, phonenumber.c_str(), phonenumber.length()) != EOK) {
return TELEPHONY_ERR_MEMCPY_FAIL;
}
return TELEPHONY_SUCCESS;
}
void ZeroBranch1Test::InitImsCallInfoList(ImsCurrentCallList &callInfoList, int32_t num)
{
callInfoList.callSize = num;
ImsCurrentCall call;
int32_t callStateSum = 6;
for (int32_t i = 0; i < num; ++i) {
call.index = i;
call.state = i % callStateSum;
callInfoList.calls.push_back(call);
}
}
void ZeroBranch1Test::MakeCallInfoParcelData(bool isError, MessageParcel &data)
{
if (isError) {
int32_t errorSize = 0;
data.WriteInt32(errorSize);
} else {
CellularCallInfo callInfo;
callInfo.slotId = -1;
int32_t size = 1;
data.WriteInt32(size);
data.WriteRawData(static_cast<const void *>(&callInfo), sizeof(CellularCallInfo));
}
}
void ZeroBranch1Test::InitCsCallInfoList(CallInfoList &callInfoList, int32_t num)
{
callInfoList.callSize = num;
CallInfo call;
int32_t callStateSum = 9;
for (int32_t i = 0; i < num; ++i) {
call.index = i;
call.state = i % callStateSum;
callInfoList.calls.push_back(call);
}
}
* @tc.number Telephony_CellularCallStub_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_001, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
MessageParcel reply;
MessageParcel dialErrorData;
MakeCallInfoParcelData(true, dialErrorData);
callStub.OnDialInner(dialErrorData, reply);
MessageParcel dialData;
MakeCallInfoParcelData(false, dialData);
callStub.OnDialInner(dialData, reply);
MessageParcel hangUpErrorData;
MakeCallInfoParcelData(true, hangUpErrorData);
callStub.OnHangUpInner(hangUpErrorData, reply);
MessageParcel hangUpData;
MakeCallInfoParcelData(false, hangUpData);
hangUpData.WriteInt32(1);
callStub.OnHangUpInner(hangUpData, reply);
MessageParcel rejectErrorData;
MakeCallInfoParcelData(true, rejectErrorData);
callStub.OnRejectInner(rejectErrorData, reply);
MessageParcel rejectData;
MakeCallInfoParcelData(false, rejectData);
callStub.OnRejectInner(rejectData, reply);
MessageParcel answerErrorData;
MakeCallInfoParcelData(true, answerErrorData);
callStub.OnAnswerInner(answerErrorData, reply);
MessageParcel answerData;
MakeCallInfoParcelData(false, answerData);
callStub.OnAnswerInner(answerData, reply);
MessageParcel holdErrorData;
MakeCallInfoParcelData(true, holdErrorData);
callStub.OnHoldCallInner(holdErrorData, reply);
MessageParcel holdData;
MakeCallInfoParcelData(false, answerData);
callStub.OnHoldCallInner(holdData, reply);
MessageParcel unholdErrorData;
MakeCallInfoParcelData(true, unholdErrorData);
callStub.OnUnHoldCallInner(unholdErrorData, reply);
MessageParcel unholdData;
MakeCallInfoParcelData(false, unholdData);
callStub.OnUnHoldCallInner(unholdData, reply);
MessageParcel switchCallErrorData;
MakeCallInfoParcelData(true, switchCallErrorData);
callStub.OnSwitchCallInner(switchCallErrorData, reply);
MessageParcel switchCallData;
MakeCallInfoParcelData(false, switchCallData);
ASSERT_EQ(callStub.OnSwitchCallInner(switchCallData, reply), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallStub_002
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_002, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
MessageParcel reply;
int32_t size = 1;
MessageParcel combineErrorData;
MakeCallInfoParcelData(true, combineErrorData);
callStub.OnCombineConferenceInner(combineErrorData, reply);
MessageParcel combineData;
MakeCallInfoParcelData(false, combineData);
callStub.OnCombineConferenceInner(combineData, reply);
MessageParcel separateErrorData;
MakeCallInfoParcelData(true, separateErrorData);
callStub.OnSeparateConferenceInner(separateErrorData, reply);
MessageParcel separateData;
MakeCallInfoParcelData(false, separateData);
callStub.OnSeparateConferenceInner(separateData, reply);
MessageParcel kickOutErrorData;
MakeCallInfoParcelData(true, kickOutErrorData);
callStub.OnKickOutFromConferenceInner(kickOutErrorData, reply);
MessageParcel kickOutData;
MakeCallInfoParcelData(false, kickOutData);
callStub.OnKickOutFromConferenceInner(kickOutData, reply);
MessageParcel stopDtmfErrorData;
MakeCallInfoParcelData(true, stopDtmfErrorData);
callStub.OnStopDtmfInner(stopDtmfErrorData, reply);
MessageParcel stopDtmfData;
MakeCallInfoParcelData(false, stopDtmfData);
callStub.OnStopDtmfInner(stopDtmfData, reply);
MessageParcel postDialErrorData;
MakeCallInfoParcelData(true, postDialErrorData);
callStub.OnPostDialProceedInner(postDialErrorData, reply);
MessageParcel postDialData;
MakeCallInfoParcelData(false, postDialData);
postDialData.WriteBool(false);
callStub.OnPostDialProceedInner(postDialData, reply);
MessageParcel cameraData;
cameraData.WriteInt32(size);
ASSERT_EQ(callStub.OnControlCameraInner(cameraData, reply), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallStub_003
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_003, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
CellularCallInfo callInfo;
callInfo.slotId = -1;
int32_t errorSize = -1;
int32_t size = 1;
MessageParcel reply;
MessageParcel hangUpAllData;
hangUpAllData.WriteInt32(size);
callStub.OnHangUpAllConnectionInner(hangUpAllData, reply);
MessageParcel startDtmfData;
startDtmfData.WriteInt32(size);
startDtmfData.WriteInt8('1');
startDtmfData.WriteRawData((const void *)&callInfo, sizeof(CellularCallInfo));
callStub.OnStartDtmfInner(startDtmfData, reply);
MessageParcel sendDtmfData;
sendDtmfData.WriteInt32(size);
sendDtmfData.WriteInt8('1');
sendDtmfData.WriteRawData((const void *)&callInfo, sizeof(CellularCallInfo));
callStub.OnSendDtmfInner(sendDtmfData, reply);
MessageParcel emergencyData;
emergencyData.WriteInt32(size);
emergencyData.WriteInt32(errorSize);
callStub.OnIsEmergencyPhoneNumberInner(emergencyData, reply);
MessageParcel setReadyData;
setReadyData.WriteInt32(errorSize);
callStub.OnSetReadyToCallInner(setReadyData, reply);
MessageParcel setCallTransferData;
setCallTransferData.WriteInt32(size);
setCallTransferData.WriteInt32(errorSize);
callStub.OnSetCallTransferInner(setCallTransferData, reply);
MessageParcel canSetTimerData;
canSetTimerData.WriteInt32(size);
canSetTimerData.WriteInt32(errorSize);
callStub.OnCanSetCallTransferTimeInner(canSetTimerData, reply);
MessageParcel getCallTransferData;
getCallTransferData.WriteInt32(size);
getCallTransferData.WriteInt32(errorSize);
callStub.OnGetCallTransferInner(getCallTransferData, reply);
MessageParcel setCallWaitData;
setCallWaitData.WriteInt32(size);
setCallWaitData.WriteInt32(errorSize);
callStub.OnSetCallWaitingInner(setCallWaitData, reply);
MessageParcel getCallWaitData;
getCallWaitData.WriteInt32(size);
getCallWaitData.WriteInt32(errorSize);
ASSERT_EQ(callStub.OnGetCallWaitingInner(getCallWaitData, reply), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallStub_004
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_004, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
int32_t errorSize = -1;
int32_t size = 1;
MessageParcel reply;
MessageParcel setCallRestData;
setCallRestData.WriteInt32(size);
setCallRestData.WriteInt32(errorSize);
callStub.OnSetCallRestrictionInner(setCallRestData, reply);
MessageParcel getCallRestData;
getCallRestData.WriteInt32(size);
getCallRestData.WriteInt32(errorSize);
callStub.OnGetCallRestrictionInner(getCallRestData, reply);
MessageParcel setCallRestPwdData;
setCallRestPwdData.WriteInt32(size);
setCallRestPwdData.WriteInt32(errorSize);
callStub.OnSetCallRestrictionPasswordInner(setCallRestPwdData, reply);
MessageParcel setDomainData;
setDomainData.WriteInt32(size);
setDomainData.WriteInt32(errorSize);
callStub.OnSetDomainPreferenceModeInner(setDomainData, reply);
MessageParcel getDomainData;
getDomainData.WriteInt32(size);
getDomainData.WriteInt32(errorSize);
callStub.OnGetDomainPreferenceModeInner(getDomainData, reply);
MessageParcel setImsSwitchData;
setImsSwitchData.WriteInt32(size);
setImsSwitchData.WriteInt32(errorSize);
callStub.OnSetImsSwitchStatusInner(setImsSwitchData, reply);
MessageParcel getImsSwitchData;
getImsSwitchData.WriteInt32(size);
getImsSwitchData.WriteInt32(errorSize);
callStub.OnGetImsSwitchStatusInner(getImsSwitchData, reply);
MessageParcel setVonrData;
setVonrData.WriteInt32(size);
setVonrData.WriteInt32(errorSize);
callStub.OnSetVoNRStateInner(setVonrData, reply);
MessageParcel getVonrData;
getVonrData.WriteInt32(size);
getVonrData.WriteInt32(errorSize);
callStub.OnGetVoNRStateInner(getVonrData, reply);
MessageParcel setconfigData;
setconfigData.WriteInt32(size);
setconfigData.WriteInt32(errorSize);
ASSERT_EQ(callStub.OnSetImsConfigStringInner(setconfigData, reply), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallStub_005
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_005, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
int32_t errorSize = -1;
int32_t size = 1;
MessageParcel reply;
MessageParcel setconfigData;
setconfigData.WriteInt32(size);
setconfigData.WriteInt32(errorSize);
callStub.OnSetImsConfigIntInner(setconfigData, reply);
MessageParcel getconfigData;
getconfigData.WriteInt32(size);
getconfigData.WriteInt32(errorSize);
callStub.OnGetImsConfigInner(getconfigData, reply);
MessageParcel setFeatureData;
setFeatureData.WriteInt32(size);
setFeatureData.WriteInt32(errorSize);
callStub.OnSetImsFeatureValueInner(setFeatureData, reply);
MessageParcel getFeatureData;
getFeatureData.WriteInt32(size);
getFeatureData.WriteInt32(errorSize);
callStub.OnGetImsFeatureValueInner(getFeatureData, reply);
MessageParcel setMuteData;
setMuteData.WriteInt32(size);
setMuteData.WriteInt32(errorSize);
callStub.OnSetMuteInner(setMuteData, reply);
MessageParcel getMuteData;
getMuteData.WriteInt32(size);
getMuteData.WriteInt32(errorSize);
callStub.OnGetMuteInner(getMuteData, reply);
MessageParcel closeUssdData;
closeUssdData.WriteInt32(size);
closeUssdData.WriteInt32(errorSize);
callStub.OnCloseUnFinishedUssdInner(closeUssdData, reply);
MessageParcel clearCallsData;
MakeCallInfoParcelData(false, clearCallsData);
ASSERT_EQ(callStub.OnClearAllCallsInner(clearCallsData, reply), TELEPHONY_SUCCESS);
MessageParcel ussdData;
ussdData.WriteInt32(0);
ussdData.WriteString("1");
ASSERT_NE(callStub.OnSendUssdResponse(ussdData, reply), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallStub_006
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_006, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
int32_t errorSize = -1;
int32_t size = 1;
MessageParcel reply;
MessageParcel setPreviewData;
setPreviewData.WriteInt32(errorSize);
callStub.OnSetPreviewWindowInner(setPreviewData, reply);
MessageParcel setDisplayData;
setDisplayData.WriteInt32(errorSize);
callStub.OnSetDisplayWindowInner(setDisplayData, reply);
MessageParcel setCameraData;
setCameraData.WriteInt32(errorSize);
callStub.OnSetCameraZoomInner(setCameraData, reply);
MessageParcel setImageData;
setImageData.WriteInt32(errorSize);
callStub.OnSetPausePictureInner(setImageData, reply);
MessageParcel setDirectionData;
setDirectionData.WriteInt32(errorSize);
callStub.OnSetDeviceDirectionInner(setDirectionData, reply);
MessageParcel setEmergencyData;
setEmergencyData.WriteInt32(size);
setEmergencyData.WriteInt32(errorSize);
setEmergencyData.WriteInt32(size);
if (setEmergencyData.WriteString("123") && setEmergencyData.WriteString("456") &&
setEmergencyData.WriteInt32(size) && setEmergencyData.WriteInt32(size) && setEmergencyData.WriteInt32(size)) {
callStub.OnSetEmergencyCallList(setEmergencyData, reply);
}
MessageParcel registerData;
registerData.WriteInt32(size);
callStub.OnRegisterCallBackInner(registerData, reply);
MessageParcel unRegisterData;
unRegisterData.WriteInt32(errorSize);
callStub.OnUnRegisterCallBackInner(unRegisterData, reply);
MessageParcel inviteData;
registerData.WriteInt32(size);
inviteData.WriteInt32(errorSize);
callStub.OnInviteToConferenceInner(inviteData, reply);
}
* @tc.number Telephony_CellularCallStub_007
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_007, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
int32_t size = 1;
MessageParcel reply;
MessageParcel callMediaModeRequestData;
MakeCallInfoParcelData(false, callMediaModeRequestData);
ImsCallMode requestMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
callMediaModeRequestData.WriteInt32(static_cast<int32_t>(requestMode));
callStub.OnSendUpdateCallMediaModeRequestInner(callMediaModeRequestData, reply);
MessageParcel callMediaModeResponseData;
MakeCallInfoParcelData(false, callMediaModeResponseData);
ImsCallMode responseMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
callMediaModeResponseData.WriteInt32(static_cast<int32_t>(responseMode));
callStub.OnSendUpdateCallMediaModeResponseInner(callMediaModeResponseData, reply);
MessageParcel callUpgradeData;
callUpgradeData.WriteInt32(size);
callUpgradeData.WriteInt32(SIM1_SLOTID);
callUpgradeData.WriteInt32(DEFAULT_INDEX);
callStub.OnCancelCallUpgradeInner(callUpgradeData, reply);
MessageParcel cameraCapabilitiesData;
cameraCapabilitiesData.WriteInt32(size);
cameraCapabilitiesData.WriteInt32(SIM1_SLOTID);
cameraCapabilitiesData.WriteInt32(DEFAULT_INDEX);
ASSERT_EQ(callStub.OnRequestCameraCapabilitiesInner(cameraCapabilitiesData, reply), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallStub_008
* @tc.name Test OnIsMmiCodeInner
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_008, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
int32_t size = 1;
MessageParcel reply;
MessageParcel mmiCodeData;
mmiCodeData.WriteInt32(size);
mmiCodeData.WriteInt32(SIM1_SLOTID);
mmiCodeData.WriteString("*100#");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData, reply), TELEPHONY_SUCCESS);
MessageParcel mmiCodeDataInvalid;
mmiCodeDataInvalid.WriteInt32(size);
mmiCodeDataInvalid.WriteInt32(-1);
mmiCodeDataInvalid.WriteString("*100#");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeDataInvalid, reply), TELEPHONY_SUCCESS);
MessageParcel mmiCodeErrData;
mmiCodeErrData.WriteInt32(-1);
mmiCodeErrData.WriteInt32(SIM1_SLOTID);
mmiCodeErrData.WriteString("*100#");
ASSERT_NE(callStub.OnIsMmiCodeInner(mmiCodeErrData, reply), TELEPHONY_SUCCESS);
TELEPHONY_EXT_WRAPPER.isMmiCode_ = IsMmiCodeMockTrue;
MessageParcel mmiCodeData1;
mmiCodeData1.WriteInt32(size);
mmiCodeData1.WriteInt32(SIM1_SLOTID);
mmiCodeData1.WriteString("*100#");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData1, reply), TELEPHONY_SUCCESS);
TELEPHONY_EXT_WRAPPER.isMmiCode_ = IsMmiCodeMockFalse;
MessageParcel mmiCodeData2;
mmiCodeData2.WriteInt32(size);
mmiCodeData2.WriteInt32(SIM1_SLOTID);
mmiCodeData2.WriteString("*100#");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData2, reply), TELEPHONY_SUCCESS);
TELEPHONY_EXT_WRAPPER.isMmiCode_ = nullptr;
MessageParcel mmiCodeData3;
mmiCodeData3.WriteInt32(size);
mmiCodeData3.WriteInt32(SIM1_SLOTID);
mmiCodeData3.WriteString("*100#");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData3, reply), TELEPHONY_SUCCESS);
TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
}
* @tc.number Telephony_CellularCallStub_009
* @tc.name Test OnIsMmiCodeInner
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_009, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
int32_t size = 1;
MessageParcel reply;
TELEPHONY_EXT_WRAPPER.isMmiCode_ = IsMmiCodeMockTrue;
MessageParcel mmiCodeData1;
mmiCodeData1.WriteInt32(size);
mmiCodeData1.WriteInt32(SIM1_SLOTID);
mmiCodeData1.WriteString("*31#1234567");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData1, reply), TELEPHONY_SUCCESS);
MessageParcel mmiCodeData2;
mmiCodeData2.WriteInt32(size);
mmiCodeData2.WriteInt32(SIM1_SLOTID);
mmiCodeData2.WriteString("#31#1234567");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData2, reply), TELEPHONY_SUCCESS);
MessageParcel mmiCodeData3;
mmiCodeData3.WriteInt32(size);
mmiCodeData3.WriteInt32(SIM1_SLOTID);
mmiCodeData3.WriteString("*#31#1234567");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData3, reply), TELEPHONY_SUCCESS);
MessageParcel mmiCodeData4;
mmiCodeData4.WriteInt32(size);
mmiCodeData4.WriteInt32(SIM1_SLOTID);
mmiCodeData4.WriteString("1234567");
ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData3, reply), TELEPHONY_SUCCESS);
TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
}
#ifdef SUPPORT_RTT_CALL
* @tc.number Telephony_CellularCallStub_010
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_010, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService callStub;
int32_t size = 1;
int32_t callId = 0;
MessageParcel reply;
MessageParcel startRttData;
startRttData.WriteInt32(size);
startRttData.WriteInt32(SIM1_SLOTID);
startRttData.WriteInt32(callId);
startRttData.WriteInt32(0);
ASSERT_EQ(callStub.OnUpdateImsRttCallModeInner(startRttData, reply), TELEPHONY_SUCCESS);
}
#endif
* @tc.number Telephony_CellularCallService_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_001, Function | MediumTest | Level3)
{
CellularCallService cellularCall;
std::vector<std::u16string> args = { u"1", u"2" };
cellularCall.Dump(-1, args);
cellularCall.Dump(1, args);
cellularCall.GetServiceRunningState();
cellularCall.GetBindTime();
cellularCall.GetEndTime();
cellularCall.GetSpendTime();
CellularCallInfo csCallInfo = { .callType = CallType::TYPE_CS };
CellularCallInfo imsCallInfo = { .callType = CallType::TYPE_IMS };
CellularCallInfo errCallInfo = { .callType = CallType::TYPE_ERR_CALL };
cellularCall.Dial(csCallInfo);
cellularCall.Dial(imsCallInfo);
cellularCall.Dial(errCallInfo);
cellularCall.HangUp(csCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
cellularCall.HangUp(imsCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
cellularCall.HangUp(errCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
cellularCall.Reject(csCallInfo);
cellularCall.Reject(imsCallInfo);
cellularCall.Reject(errCallInfo);
cellularCall.Answer(csCallInfo);
cellularCall.Answer(imsCallInfo);
cellularCall.Answer(errCallInfo);
cellularCall.HoldCall(csCallInfo);
cellularCall.HoldCall(imsCallInfo);
cellularCall.HoldCall(errCallInfo);
cellularCall.UnHoldCall(csCallInfo);
cellularCall.UnHoldCall(imsCallInfo);
cellularCall.UnHoldCall(errCallInfo);
cellularCall.SwitchCall(csCallInfo);
cellularCall.SwitchCall(imsCallInfo);
cellularCall.SwitchCall(errCallInfo);
bool enabled = false;
std::string phoneNum = "000";
cellularCall.IsEmergencyPhoneNumber(INVALID_SLOTID, phoneNum, enabled);
ASSERT_EQ(cellularCall.IsEmergencyPhoneNumber(SIM1_SLOTID, phoneNum, enabled), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallService_002
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_002, Function | MediumTest | Level3)
{
CellularCallService cellularCall;
CellularCallInfo csCallInfo = { .callType = CallType::TYPE_CS };
CellularCallInfo imsCallInfo = { .callType = CallType::TYPE_IMS };
CellularCallInfo errCallInfo = { .callType = CallType::TYPE_ERR_CALL };
EmergencyCall ecc;
std::vector<EmergencyCall> eccVec;
eccVec.push_back(ecc);
cellularCall.SetEmergencyCallList(SIM1_SLOTID, eccVec);
cellularCall.CombineConference(csCallInfo);
cellularCall.CombineConference(imsCallInfo);
cellularCall.CombineConference(errCallInfo);
cellularCall.SeparateConference(csCallInfo);
cellularCall.SeparateConference(imsCallInfo);
cellularCall.SeparateConference(errCallInfo);
std::vector<std::string> numberList = { "111", "222" };
cellularCall.InviteToConference(SIM1_SLOTID, numberList);
cellularCall.KickOutFromConference(csCallInfo);
cellularCall.KickOutFromConference(imsCallInfo);
cellularCall.KickOutFromConference(errCallInfo);
cellularCall.HangUpAllConnection();
cellularCall.HangUpAllConnection(SIM1_SLOTID);
cellularCall.SetReadyToCall(SIM1_SLOTID, 0, true);
cellularCall.SetReadyToCall(SIM1_SLOTID, 1, true);
cellularCall.SetReadyToCall(SIM1_SLOTID, 3, true);
cellularCall.StartDtmf('*', csCallInfo);
cellularCall.StartDtmf('*', imsCallInfo);
cellularCall.StartDtmf('*', errCallInfo);
cellularCall.StopDtmf(csCallInfo);
cellularCall.StopDtmf(imsCallInfo);
cellularCall.StopDtmf(errCallInfo);
cellularCall.PostDialProceed(csCallInfo, true);
cellularCall.PostDialProceed(imsCallInfo, true);
cellularCall.PostDialProceed(errCallInfo, true);
cellularCall.SendDtmf('*', csCallInfo);
cellularCall.SendDtmf('*', imsCallInfo);
cellularCall.SendDtmf('*', errCallInfo);
#ifdef SUPPORT_RTT_CALL
int32_t callId = 0;
ASSERT_NE(cellularCall.UpdateImsRttCallMode(SIM1_SLOTID, callId, ImsRTTCallMode::LOCAL_REQUEST_UPGRADE),
TELEPHONY_SUCCESS);
#endif
}
* @tc.number Telephony_CellularCallService_003
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_003, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService cellularCall;
CallTransferInfo cTInfoDisable = { .settingType = CallTransferSettingType::CALL_TRANSFER_DISABLE };
CallTransferInfo cTInfoEnable = { .settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE };
cellularCall.SetCallTransferInfo(SIM1_SLOTID, cTInfoDisable);
cellularCall.SetCallTransferInfo(SIM1_SLOTID, cTInfoEnable);
bool result = false;
cellularCall.CanSetCallTransferTime(SIM1_SLOTID, result);
cellularCall.GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL);
cellularCall.SetCallWaiting(SIM1_SLOTID, true);
cellularCall.GetCallWaiting(SIM1_SLOTID);
CallRestrictionInfo crInfo;
cellularCall.SetCallRestriction(SIM1_SLOTID, crInfo);
cellularCall.GetCallRestriction(SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING);
std::string password = "1111";
cellularCall.SetCallRestrictionPassword(
SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING, password.c_str(), password.c_str());
cellularCall.SetDomainPreferenceMode(SIM1_SLOTID, 1);
cellularCall.GetDomainPreferenceMode(SIM1_SLOTID);
cellularCall.SetImsSwitchStatus(SIM1_SLOTID, true);
bool enabled = false;
cellularCall.GetImsSwitchStatus(SIM1_SLOTID, enabled);
std::string value = "";
cellularCall.SetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_VIDEO_QUALITY, value);
int32_t state = 0;
cellularCall.SetVoNRState(SIM1_SLOTID, state);
cellularCall.GetVoNRState(SIM1_SLOTID, state);
cellularCall.SetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_VIDEO_QUALITY, 1);
cellularCall.GetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_VIDEO_QUALITY);
cellularCall.SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE, 1);
cellularCall.GetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE);
std::string cameraId = "";
cellularCall.ControlCamera(SIM1_SLOTID, DEFAULT_INDEX, cameraId);
std::string surfaceId = "";
cellularCall.SetPreviewWindow(SIM1_SLOTID, DEFAULT_INDEX, surfaceId, nullptr);
cellularCall.SetDisplayWindow(SIM1_SLOTID, DEFAULT_INDEX, surfaceId, nullptr);
cellularCall.SetCameraZoom(1.0);
std::string path = "";
cellularCall.SetPausePicture(SIM1_SLOTID, DEFAULT_INDEX, path);
cellularCall.SetDeviceDirection(SIM1_SLOTID, DEFAULT_INDEX, 0);
CellularCallInfo cellularCallInfo;
InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, cellularCallInfo);
cellularCall.SendUpdateCallMediaModeRequest(cellularCallInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY);
cellularCall.SendUpdateCallMediaModeResponse(cellularCallInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY);
cellularCall.CancelCallUpgrade(SIM1_SLOTID, DEFAULT_INDEX);
}
* @tc.number Telephony_CellularCallService_004
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_004, Function | MediumTest | Level3)
{
AccessToken token;
CellularCallService cellularCall;
cellularCall.SetMute(SIM1_SLOTID, 0);
cellularCall.GetMute(SIM1_SLOTID);
cellularCall.CloseUnFinishedUssd(SIM1_SLOTID);
std::vector<CellularCallInfo> infos = {};
cellularCall.ClearAllCalls(infos);
cellularCall.IsNeedIms(SIM1_SLOTID);
cellularCall.IsNeedIms(SIM2_SLOTID);
cellularCall.GetCsControl(SIM1_SLOTID);
cellularCall.GetImsControl(SIM1_SLOTID);
std::shared_ptr<CSControl> csControl;
cellularCall.SetCsControl(SIM1_SLOTID, csControl);
std::shared_ptr<IMSControl> imsControl;
cellularCall.SetImsControl(SIM1_SLOTID, imsControl);
cellularCall.GetHandler(SIM1_SLOTID);
cellularCall.SetSrvccState(SrvccState::SRVCC_NONE);
cellularCall.GetSrvccState();
cellularCall.RegisterHandler();
#ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
cellularCall.StartCallManagerService();
ASSERT_EQ(cellularCall.RequestCameraCapabilities(SIM1_SLOTID, DEFAULT_INDEX), INVALID_VALUE);
#else
ASSERT_EQ(cellularCall.RequestCameraCapabilities(SIM1_SLOTID, DEFAULT_INDEX), TELEPHONY_SUCCESS);
#endif
cellularCall.Init();
cellularCall.RegisterCoreServiceHandler();
cellularCall.CreateHandler();
cellularCall.SendEventRegisterHandler();
cellularCall.IsValidSlotId(SIM1_SLOTID);
CellularCallInfo imsCallInfo = { .callType = CallType::TYPE_IMS };
CellularCallInfo csCallInfo = { .callType = CallType::TYPE_CS };
cellularCall.UseImsForEmergency(imsCallInfo, true);
cellularCall.HandleCallManagerException();
cellularCall.HandleCellularControlException(imsCallInfo);
cellularCall.HandleCellularControlException(csCallInfo);
cellularCall.HangUpWithCellularCallRestart(infos);
cellularCall.SetControl(imsCallInfo);
cellularCall.SetControl(csCallInfo);
sptr<ICallStatusCallback> callback;
cellularCall.RegisterCallManagerCallBack(callback);
cellularCall.UnRegisterCallManagerCallBack();
cellularCall.HandlerResetUnRegister();
cellularCall.OnStop();
cellularCall.SendUssdResponse(0, "1");
ASSERT_EQ(callback, nullptr);
}
#ifdef BASE_POWER_IMPROVEMENT_FEATURE
* @tc.number Telephony_CellularCallService_005
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_005, Function | MediumTest | Level3)
{
std::shared_ptr<MockSimManager> mockSimManagerPtr(mockSimManager);
CoreManagerInner::GetInstance().OnInit(nullptr, mockSimManagerPtr, nullptr);
SimLabel expectedSimLabel;
expectedSimLabel.simType = SimType::ESIM;
EXPECT_CALL(*mockSimManager, GetSimLabel(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(expectedSimLabel), Return(0)));
EventFwk::MatchingSkills matchingSkills;
matchingSkills.AddEvent(ENTER_STR_TELEPHONY_NOTIFY);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
auto handler = std::make_shared<CellularCallHandler>(subscriberInfo);
IMSControl imsControl;
ImsCurrentCallList ImsCallList;
handler->ReportImsCallsData(ImsCallList);
InitImsCallInfoList(ImsCallList, 1);
imsControl.ReportIncomingInfo(SIM1_SLOTID, ImsCallList);
handler->ReportImsCallsData(ImsCallList);
EventFwk::CommonEventData eventData = EventFwk::CommonEventData();
AAFwk::Want want = AAFwk::Want();
want.SetAction(ENTER_STR_TELEPHONY_NOTIFY);
eventData.SetWant(want);
handler->OnReceiveEvent(eventData);
CSControl csControl;
CellularCallInfo cellularCallInfo;
InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, cellularCallInfo);
CallInfoList callInfoList;
handler->ReportCsCallsData(callInfoList);
csControl.connectionMap_.insert(std::make_pair(1, CellularCallConnectionCS()));
handler->ReportCsCallsData(callInfoList);
handler->OnReceiveEvent(eventData);
InitImsCallInfoList(ImsCallList, 0);
handler->ReportImsCallsData(ImsCallList);
csControl.connectionMap_.clear();
handler->ReportCsCallsData(callInfoList);
}
#endif
* @tc.number Telephony_CellularCallService_With2Calls
* @tc.name Test ReportImsCallsData when imsCallInfoList.callsize == 2
* @tc.desc Function test: Verify IMSControl is created when callSize == 2 and imsControl is null
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_With2Calls, Function | MediumTest | Level3)
{
EventFwk::MatchingSkills matchingSkills;
matchingSkills.AddEvent(ENTER_STR_TELEPHONY_NOTIFY);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
auto handler = std::make_shared<CellularCallHandler>(subscriberInfo);
auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
serviceInstance->SetImsControl(SIM1_SLOTID, nullptr);
ImsCurrentCallList imsCallList;
InitImsCallInfoList(imsCallList, 2);
handler->ReportImsCallsData(imsCallList);
auto imsControl = serviceInstance->GetImsControl(SIM1_SLOTID);
EXPECT_NE(imsControl, nullptr);
}
* @tc.number Telephony_CellularCallService_With2Calls_NoCreate
* @tc.name Test ReportImsCallsData when imsCallInfoList.callsize == 2
* @tc.desc Function test: Verify IMSControl is created when callSize == 2 and imsControl is exist
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_With2Calls_NoCreate, Function | MediumTest | Level3)
{
EventFwk::MatchingSkills matchingSkills;
matchingSkills.AddEvent(ENTER_STR_TELEPHONY_NOTIFY);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
auto handler = std::make_shared<CellularCallHandler>(subscriberInfo);
auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
auto imsControl = std::make_shared<IMSControl>();
serviceInstance->SetImsControl(SIM1_SLOTID, imsControl);
ImsCurrentCallList imsCallList;
InitImsCallInfoList(imsCallList, 2);
handler->ReportImsCallsData(imsCallList);
auto imsControl2 = serviceInstance->GetImsControl(SIM1_SLOTID);
EXPECT_EQ(imsControl2, imsControl);
}
* @tc.number Telephony_CellularCallService_With3Calls
* @tc.name Test ReportImsCallsData when imsCallInfoList.callsize == 3
* @tc.desc Function test: Verify IMSControl not be created when callSize == 3 and imsControl is null
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_With3Calls, Function | MediumTest | Level3)
{
EventFwk::MatchingSkills matchingSkills;
matchingSkills.AddEvent(ENTER_STR_TELEPHONY_NOTIFY);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
auto handler = std::make_shared<CellularCallHandler>(subscriberInfo);
auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
serviceInstance->SetImsControl(SIM1_SLOTID, nullptr);
ImsCurrentCallList imsCallList;
InitImsCallInfoList(imsCallList, 3);
handler->ReportImsCallsData(imsCallList);
auto imsControl = serviceInstance->GetImsControl(SIM1_SLOTID);
EXPECT_EQ(imsControl, nullptr);
}
* @tc.number Telephony_CellularCallSupplementRequestIms_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallSupplementRequestIms_001, Function | MediumTest | Level3)
{
SupplementRequestIms SRequestIms;
CallTransferInfo CTransferInfo;
std::string fac = "";
SRequestIms.SetClipRequest(SIM1_SLOTID, ACTIVATE_ACTION, 0);
SRequestIms.GetClipRequest(SIM1_SLOTID, 0);
SRequestIms.SetClirRequest(SIM1_SLOTID, ACTIVATE_ACTION, 0);
SRequestIms.GetClirRequest(SIM1_SLOTID, 0);
SRequestIms.GetCallTransferRequest(SIM1_SLOTID, 0, 0);
SRequestIms.SetCallTransferRequest(SIM1_SLOTID, CTransferInfo, ACTIVATE_ACTION, 0);
bool enable = false;
SRequestIms.CanSetCallTransferTime(SIM1_SLOTID, enable);
SRequestIms.GetCallRestrictionRequest(SIM1_SLOTID, fac, 0);
std::string pw = "";
SRequestIms.SetCallRestrictionRequest(SIM1_SLOTID, fac, 0, pw, 0);
SRequestIms.SetCallWaitingRequest(SIM1_SLOTID, true, 0, 0);
SRequestIms.GetCallWaitingRequest(SIM1_SLOTID, 0);
SRequestIms.SetColrRequest(SIM1_SLOTID, 0, 0);
SRequestIms.GetColrRequest(SIM1_SLOTID, 0);
SRequestIms.SetColpRequest(SIM1_SLOTID, 0, 0);
SRequestIms.GetMMIHandler(SIM1_SLOTID);
ASSERT_NE(SRequestIms.GetColpRequest(SIM1_SLOTID, 0), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_CellularCallbaseconnection_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallbaseconnection_001, Function | MediumTest | Level3)
{
BaseConnection BConnection;
char c = ' ';
BConnection.postDialCalltate_ = PostDialCallState::POST_DIAL_CALL_CANCELED;
EXPECT_EQ(BConnection.ProcessNextChar(SIM1_SLOTID, c), 5);
EXPECT_EQ(BConnection.GetLeftPostDialCallString(), "");
BConnection.postDialCallString_ = "111111";
EXPECT_EQ(BConnection.ProcessNextChar(SIM1_SLOTID, c), 5);
BConnection.postDialCalltate_ = PostDialCallState::POST_DIAL_CALL_NOT_STARTED;
EXPECT_NE(BConnection.ProcessNextChar(SIM1_SLOTID, c), 5);
EXPECT_NE(BConnection.GetLeftPostDialCallString(), "");
}
* @tc.number Telephony_CellularCallHiSysEvent_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallHiSysEvent_001, Function | MediumTest | Level3)
{
std::shared_ptr<CellularCallHiSysEvent> cellularCallHiSysEvent = std::make_shared<CellularCallHiSysEvent>();
std::string desc;
cellularCallHiSysEvent->WriteFoundationRestartFaultEvent(2);
CallBehaviorParameterInfo Info = { .callType = 1 };
CallResponseResult result = CallResponseResult::COMMAND_FAILURE;
cellularCallHiSysEvent->WriteDialCallBehaviorEvent(Info, result);
result = CallResponseResult::COMMAND_SUCCESS;
cellularCallHiSysEvent->WriteDialCallBehaviorEvent(Info, result);
Info = { .callType = 0 };
cellularCallHiSysEvent->WriteDialCallBehaviorEvent(Info, result);
Info = { .callType = 1 };
result = CallResponseResult::COMMAND_FAILURE;
cellularCallHiSysEvent->WriteHangUpCallBehaviorEvent(Info, result);
result = CallResponseResult::COMMAND_SUCCESS;
cellularCallHiSysEvent->WriteHangUpCallBehaviorEvent(Info, result);
Info = { .callType = 0 };
cellularCallHiSysEvent->WriteHangUpCallBehaviorEvent(Info, result);
cellularCallHiSysEvent->WriteIncomingCallFaultEvent(
0, 0, 0, static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), desc);
cellularCallHiSysEvent->WriteIncomingCallFaultEvent(0, 0, 0, -1, desc);
cellularCallHiSysEvent->JudgingIncomingTimeOut(0, 0, 0);
CallForwardingInfo cfInfo;
cellularCallHiSysEvent->GetCallForwardingInfo(cfInfo);
ASSERT_TRUE(desc.empty());
}
* @tc.number Telephony_CellularCallHiSysEvent_002
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallHiSysEvent_002, Function | MediumTest | Level3)
{
std::shared_ptr<CellularCallHiSysEvent> cellularCallHiSysEvent = std::make_shared<CellularCallHiSysEvent>();
CallErrorCode eventValue;
cellularCallHiSysEvent->TelephonyErrorCodeConversion(-1, eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(
static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL), eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(
static_cast<int32_t>(TELEPHONY_ERR_ARGUMENT_INVALID), eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(
static_cast<int32_t>(TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL), eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(
static_cast<int32_t>(TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL), eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(
static_cast<int32_t>(TELEPHONY_ERR_WRITE_DATA_FAIL), eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(
static_cast<int32_t>(TELEPHONY_ERR_PERMISSION_ERR), eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMSET_FAIL), eventValue);
cellularCallHiSysEvent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(-1, eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_CALLID), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_NUMBER_OUT_OF_RANGE), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_UNSUPPORTED_NETWORK_TYPE), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_DIAL_SCENE), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_INVALID_VIDEO_STATE), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_CALL_TYPE), eventValue);
cellularCallHiSysEvent->CallDataErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_CALL_OBJECT_IS_NULL), eventValue);
cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(-1, eventValue);
cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(static_cast<int32_t>(CALL_ERR_DIAL_IS_BUSY), eventValue);
cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_ILLEGAL_CALL_OPERATION), eventValue);
cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED), eventValue);
cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE), eventValue);
cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT), eventValue);
ASSERT_NE(cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
static_cast<int32_t>(CALL_ERR_GET_RADIO_STATE_FAILED), eventValue), 0);
}
* @tc.number Telephony_CellularCallConnectionCs_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConnectionCs_001, Function | MediumTest | Level3)
{
CellularCallConnectionCS cellularCallConnectionCS;
DialRequestStruct dialRequestStruct;
cellularCallConnectionCS.DialRequest(SIM2_SLOTID, dialRequestStruct);
cellularCallConnectionCS.HangUpRequest(SIM2_SLOTID);
cellularCallConnectionCS.AnswerRequest(SIM2_SLOTID);
cellularCallConnectionCS.AnswerRequest(SIM1_SLOTID);
cellularCallConnectionCS.RejectRequest(SIM2_SLOTID);
cellularCallConnectionCS.HoldRequest(SIM2_SLOTID);
cellularCallConnectionCS.UnHoldCallRequest(SIM2_SLOTID);
cellularCallConnectionCS.SwitchCallRequest(SIM2_SLOTID);
cellularCallConnectionCS.CombineConferenceRequest(SIM2_SLOTID, 0);
cellularCallConnectionCS.SeparateConferenceRequest(SIM2_SLOTID, 0, 0);
cellularCallConnectionCS.CallSupplementRequest(SIM2_SLOTID, CallSupplementType::TYPE_DEFAULT);
char cDtmfCode = ' ';
cellularCallConnectionCS.SendDtmfRequest(SIM2_SLOTID, cDtmfCode, 0);
cellularCallConnectionCS.StartDtmfRequest(SIM2_SLOTID, cDtmfCode, 0);
cellularCallConnectionCS.StopDtmfRequest(SIM2_SLOTID, 0);
cellularCallConnectionCS.GetCsCallsDataRequest(SIM2_SLOTID, 0);
cellularCallConnectionCS.GetCallFailReasonRequest(SIM2_SLOTID);
ASSERT_EQ(cellularCallConnectionCS.ProcessPostDialCallChar(SIM1_SLOTID, cDtmfCode), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_SupplementRequestCs_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_SupplementRequestCs_001, Function | MediumTest | Level3)
{
SupplementRequestCs supplementRequestCs;
std::string msg = "11111";
std::string fac = "";
std::string pw = "";
std::string oldPin = "123456";
std::string newPin = "789101";
std::string puk = "22222";
CallTransferParam callTransferParam;
ASSERT_EQ(supplementRequestCs.SendUssdRequest(SIM1_SLOTID, msg), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.CloseUnFinishedUssdRequest(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.SetClirRequest(SIM1_SLOTID, ACTIVATE_ACTION, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.GetClipRequest(SIM1_SLOTID, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.GetClirRequest(SIM1_SLOTID, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.SetCallTransferRequest(SIM1_SLOTID, callTransferParam, 0),
TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.GetCallTransferRequest(SIM1_SLOTID, 0, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.GetCallRestrictionRequest(SIM1_SLOTID, fac, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.SetCallRestrictionRequest(SIM1_SLOTID, fac, 0, pw, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.SetBarringPasswordRequest(SIM1_SLOTID, msg, 0, oldPin.c_str(), newPin.c_str()),
TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.SetCallWaitingRequest(SIM1_SLOTID, true, 0, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
ASSERT_EQ(supplementRequestCs.AlterPinPassword(SIM1_SLOTID, newPin, oldPin), TELEPHONY_ERROR);
ASSERT_EQ(supplementRequestCs.UnlockPuk(SIM1_SLOTID, newPin, puk), TELEPHONY_ERROR);
ASSERT_EQ(supplementRequestCs.AlterPin2Password(SIM1_SLOTID, newPin, oldPin), TELEPHONY_ERROR);
ASSERT_EQ(supplementRequestCs.UnlockPuk2(SIM1_SLOTID, newPin, puk), TELEPHONY_ERROR);
ASSERT_EQ(supplementRequestCs.GetCallWaitingRequest(SIM1_SLOTID, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
}
* @tc.number Telephony_StandardizeUtils_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_StandardizeUtils_001, Function | MediumTest | Level3)
{
StandardizeUtils standardizeUtils;
std::string phoneString = {0};
std::string networkAddress = "1111111";
std::string postDial = "11111111";
ASSERT_EQ(standardizeUtils.RemoveSeparatorsPhoneNumber(phoneString), "");
phoneString = "1111111,123321";
standardizeUtils.ExtractAddressAndPostDial(phoneString, networkAddress, postDial);
ASSERT_EQ(postDial, "11111111,123321");
std::vector<std::string> split = standardizeUtils.Split(phoneString, ",");
ASSERT_FALSE(split.empty());
}
* @tc.number Telephony_MmiCodeUtils_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_MmiCodeUtils_001, Function | MediumTest | Level3)
{
MMICodeUtils mmiCodeUtils;
bool enable = false;
ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi("111111#", enable));
mmiCodeUtils.isNeedUseIms_ = true;
ASSERT_FALSE(mmiCodeUtils.ExecuteMmiCode(SIM1_SLOTID));
mmiCodeUtils.isNeedUseIms_ = false;
mmiCodeUtils.mmiData_.serviceCode = "11111";
ASSERT_FALSE(mmiCodeUtils.ExecuteMmiCode(SIM1_SLOTID));
mmiCodeUtils.mmiData_.serviceCode.clear();
mmiCodeUtils.mmiData_.fullString = "11111";
ASSERT_TRUE(mmiCodeUtils.ExecuteMmiCode(SIM1_SLOTID));
mmiCodeUtils.mmiData_.fullString.clear();
mmiCodeUtils.mmiData_.dialString = "11111#";
ASSERT_FALSE(mmiCodeUtils.RegexMatchMmi("111111#"));
std::string dialStr = "";
ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
dialStr = "12";
ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
dialStr = "33";
ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
dialStr = "*21*10086#";
ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
dialStr = "10086";
ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
dialStr = "*30#10086";
ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
dialStr = "*33##123#";
ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
}
* @tc.number Telephony_CellularCallRdbHelper_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallRdbHelper_001, Function | MediumTest | Level3)
{
CellularCallConfig config;
std::vector<EmergencyCall> tempEccList;
EmergencyCall call;
std::vector<std::string> callList;
std::string mcc;
std::u16string u16Hplmn = u"";
CoreManagerInner::GetInstance().GetSimOperatorNumeric(SIM1_SLOTID, u16Hplmn);
std::string hplmn = Str16ToStr8(u16Hplmn);
config.UpdateHplmnFakeEccList(callList, hplmn, SIM1_SLOTID, tempEccList, mcc);
config.UpdateEccListByFakeEccList(SIM1_SLOTID, tempEccList);
std::vector<EccNum> eccVec;
auto rdbHelper = DelayedSingleton<CellularCallRdbHelper>::GetInstance();
EXPECT_NE(rdbHelper->QueryEccList(hplmn, eccVec), TELEPHONY_SUCCESS);
sptr<AAFwk::IDataAbilityObserver> callback = sptr<CellularCallService::EmergencyInfoObserver>::MakeSptr();
rdbHelper->RegisterEccDataObserver(callback);
callback = nullptr;
rdbHelper->RegisterEccDataObserver(callback);
std::vector<std::string> callListWithCard;
std::vector<std::string> callListNoCard;
config.hplmnEccList_[0].plmn = "";
bool isHplmnEccList = false;
config.ProcessHplmnEccList(0, "", isHplmnEccList, callListWithCard, callListNoCard);
config.hplmnEccList_[0].plmn = "test";
config.ProcessHplmnEccList(0, "", isHplmnEccList, callListWithCard, callListNoCard);
callListNoCard.push_back("element1");
config.ProcessHplmnEccList(0, "test", isHplmnEccList, callListWithCard, callListNoCard);
}
* @tc.number Telephony_CellularCallDumpHelper_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallDumpHelper_001, Function | MediumTest | Level3)
{
CellularCallDumpHelper cellularCallDumpHelper;
std::vector<std::string> args = { "123456", "234567" };
std::string result;
cellularCallDumpHelper.WhetherHasSimCard(SIM1_SLOTID);
ASSERT_NE(cellularCallDumpHelper.Dump(args, result), TELEPHONY_SUCCESS);
}
* @tc.number Telephony_EmergencyUtils_001
* @tc.name Test error branch
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_EmergencyUtils_001, Function | MediumTest | Level3)
{
EmergencyUtils emergencyUtils;
std::string phoneNum = "1234567";
bool enabled = false;
ASSERT_EQ(emergencyUtils.IsEmergencyCall(SIM1_SLOTID, phoneNum, enabled), TELEPHONY_SUCCESS);
}
#ifdef CELLULAR_CALL_REDCAP_ABILITY
static int32_t g_setPreferredNetworkByConfigSlotId = -1;
void SetPreferredNetworkByConfigMock(int32_t slotId)
{
g_setPreferredNetworkByConfigSlotId = slotId;
}
static int32_t g_handleRedcapFactoryResetSlotId = -1;
void HandleRedcapFactoryResetMock(int32_t slotId)
{
g_handleRedcapFactoryResetSlotId = slotId;
}
#endif
#ifdef CELLULAR_CALL_REDCAP_ABILITY
* @tc.number Telephony_CellularCallConfig_SetRadioOn_001
* @tc.name Test SetRadioOn
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_SetRadioOn_001, Function | MediumTest | Level3)
{
CellularCallConfig config;
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
CellularCallConfig::SetRadioOn(true);
ASSERT_TRUE(CellularCallConfig::isRadioOn_);
CellularCallConfig::SetRadioOn(false);
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
}
* @tc.number Telephony_CellularCallConfig_SetPreferredNetworkByConfig_001
* @tc.name Test SetPreferredNetworkByConfig when both flags false
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_SetPreferredNetworkByConfig_001,
Function | MediumTest | Level3)
{
CellularCallConfig config;
CellularCallConfig::isRadioOn_ = false;
CellularCallConfig::isOperatorConfigChanged_ = false;
g_setPreferredNetworkByConfigSlotId = -1;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = SetPreferredNetworkByConfigMock;
config.SetPreferredNetworkByConfig(SIM1_SLOTID);
ASSERT_EQ(g_setPreferredNetworkByConfigSlotId, -1);
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
ASSERT_FALSE(CellularCallConfig::isOperatorConfigChanged_);
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = nullptr;
}
* @tc.number Telephony_CellularCallConfig_SetPreferredNetworkByConfig_002
* @tc.name Test SetPreferredNetworkByConfig when isRadioOn_ true
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_SetPreferredNetworkByConfig_002,
Function | MediumTest | Level3)
{
CellularCallConfig config;
CellularCallConfig::isRadioOn_ = true;
CellularCallConfig::isOperatorConfigChanged_ = false;
g_setPreferredNetworkByConfigSlotId = -1;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = SetPreferredNetworkByConfigMock;
config.SetPreferredNetworkByConfig(SIM1_SLOTID);
ASSERT_EQ(g_setPreferredNetworkByConfigSlotId, SIM1_SLOTID);
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
ASSERT_FALSE(CellularCallConfig::isOperatorConfigChanged_);
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = nullptr;
}
* @tc.number Telephony_CellularCallConfig_SetPreferredNetworkByConfig_003
* @tc.name Test SetPreferredNetworkByConfig when isOperatorConfigChanged_ true
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_SetPreferredNetworkByConfig_003,
Function | MediumTest | Level3)
{
CellularCallConfig config;
CellularCallConfig::isRadioOn_ = false;
CellularCallConfig::isOperatorConfigChanged_ = true;
g_setPreferredNetworkByConfigSlotId = -1;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = SetPreferredNetworkByConfigMock;
config.SetPreferredNetworkByConfig(SIM2_SLOTID);
ASSERT_EQ(g_setPreferredNetworkByConfigSlotId, SIM2_SLOTID);
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
ASSERT_FALSE(CellularCallConfig::isOperatorConfigChanged_);
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = nullptr;
}
* @tc.number Telephony_CellularCallConfig_SetPreferredNetworkByConfig_004
* @tc.name Test SetPreferredNetworkByConfig with nullptr ext wrapper
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_SetPreferredNetworkByConfig_004,
Function | MediumTest | Level3)
{
CellularCallConfig config;
CellularCallConfig::isRadioOn_ = true;
CellularCallConfig::isOperatorConfigChanged_ = false;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = nullptr;
config.SetPreferredNetworkByConfig(SIM1_SLOTID);
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
ASSERT_FALSE(CellularCallConfig::isOperatorConfigChanged_);
}
* @tc.number Telephony_CellularCallConfig_HandleOperatorConfigChanged_001
* @tc.name Test HandleOperatorConfigChanged sets isOperatorConfigChanged_
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_HandleOperatorConfigChanged_001,
Function | MediumTest | Level3)
{
CellularCallConfig config;
CellularCallConfig::isOperatorConfigChanged_ = false;
config.HandleOperatorConfigChanged(SIM1_SLOTID, 0);
ASSERT_TRUE(CellularCallConfig::isOperatorConfigChanged_);
CellularCallConfig::isOperatorConfigChanged_ = false;
}
* @tc.number Telephony_CellularCallConfig_HandleFactoryReset_001
* @tc.name Test HandleFactoryReset calls handleRedcapFactoryReset_
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_HandleFactoryReset_001,
Function | MediumTest | Level3)
{
CellularCallConfig config;
g_handleRedcapFactoryResetSlotId = -1;
TELEPHONY_EXT_WRAPPER.handleRedcapFactoryReset_ = HandleRedcapFactoryResetMock;
config.HandleFactoryReset(SIM1_SLOTID);
ASSERT_EQ(g_handleRedcapFactoryResetSlotId, SIM1_SLOTID);
TELEPHONY_EXT_WRAPPER.handleRedcapFactoryReset_ = nullptr;
}
* @tc.number Telephony_CellularCallConfig_HandleFactoryReset_002
* @tc.name Test HandleFactoryReset with nullptr ext wrapper
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_HandleFactoryReset_002,
Function | MediumTest | Level3)
{
CellularCallConfig config;
TELEPHONY_EXT_WRAPPER.handleRedcapFactoryReset_ = nullptr;
config.HandleFactoryReset(SIM1_SLOTID);
}
* @tc.number Telephony_CellularCallConfig_HandleSetLteImsSwitchResult_001
* @tc.name Test HandleSetLteImsSwitchResult calls SetPreferredNetworkByConfig
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConfig_HandleSetLteImsSwitchResult_001,
Function | MediumTest | Level3)
{
CellularCallConfig config;
CellularCallConfig::isRadioOn_ = true;
CellularCallConfig::isOperatorConfigChanged_ = false;
g_setPreferredNetworkByConfigSlotId = -1;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = SetPreferredNetworkByConfigMock;
config.HandleSetLteImsSwitchResult(SIM1_SLOTID, ErrType::NONE);
ASSERT_EQ(g_setPreferredNetworkByConfigSlotId, SIM1_SLOTID);
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
ASSERT_FALSE(CellularCallConfig::isOperatorConfigChanged_);
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = nullptr;
}
* @tc.number Telephony_CellularCallHandler_GetImsSwitchStatusResponse_001
* @tc.name Test GetImsSwitchStatusResponse active == isVolteSupport calls SetPreferredNetworkByConfig
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallHandler_GetImsSwitchStatusResponse_001,
Function | MediumTest | Level3)
{
AccessToken token;
EventFwk::MatchingSkills matchingSkills;
matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
CellularCallHandler handler(subscriberInfo);
handler.SetSlotId(SIM1_SLOTID);
CellularCallConfig::isRadioOn_ = true;
CellularCallConfig::isOperatorConfigChanged_ = false;
g_setPreferredNetworkByConfigSlotId = -1;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = SetPreferredNetworkByConfigMock;
auto imsActive = std::make_shared<int32_t>(0);
auto responseEvent = AppExecFwk::InnerEvent::Get(0, imsActive);
handler.GetImsSwitchStatusResponse(responseEvent);
ASSERT_EQ(g_setPreferredNetworkByConfigSlotId, SIM1_SLOTID);
ASSERT_FALSE(CellularCallConfig::isRadioOn_);
ASSERT_FALSE(CellularCallConfig::isOperatorConfigChanged_);
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = nullptr;
}
* @tc.number Telephony_CellularCallHandler_GetImsSwitchStatusResponse_002
* @tc.name Test GetImsSwitchStatusResponse active != isVolteSupport returns early
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallHandler_GetImsSwitchStatusResponse_002,
Function | MediumTest | Level3)
{
AccessToken token;
EventFwk::MatchingSkills matchingSkills;
matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
CellularCallHandler handler(subscriberInfo);
handler.SetSlotId(SIM1_SLOTID);
CellularCallConfig::isRadioOn_ = true;
g_setPreferredNetworkByConfigSlotId = -1;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = SetPreferredNetworkByConfigMock;
auto imsActive = std::make_shared<int32_t>(1);
auto responseEvent = AppExecFwk::InnerEvent::Get(0, imsActive);
handler.GetImsSwitchStatusResponse(responseEvent);
ASSERT_EQ(g_setPreferredNetworkByConfigSlotId, -1);
ASSERT_TRUE(CellularCallConfig::isRadioOn_);
CellularCallConfig::isRadioOn_ = false;
TELEPHONY_EXT_WRAPPER.setPreferredNetworkByConfig_ = nullptr;
}
* @tc.number Telephony_CellularCallHandler_RadioStateChangeProcess_001
* @tc.name Test RadioStateChangeProcess calls SetRadioOn(true) on CORE_SERVICE_POWER_ON
* @tc.desc Function test
*/
HWTEST_F(ZeroBranch1Test, Telephony_CellularCallHandler_RadioStateChangeProcess_001,
Function | MediumTest | Level3)
{
AccessToken token;
EventFwk::MatchingSkills matchingSkills;
matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
CellularCallHandler handler(subscriberInfo);
handler.SetSlotId(SIM1_SLOTID);
CellularCallConfig::isRadioOn_ = false;
auto radioState = std::make_shared<Int32Parcel>();
radioState->data = CORE_SERVICE_POWER_ON;
auto event = AppExecFwk::InnerEvent::Get(0, radioState);
handler.RadioStateChangeProcess(event);
ASSERT_TRUE(CellularCallConfig::isRadioOn_);
CellularCallConfig::isRadioOn_ = false;
}
#endif
}
}
