1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define private public
16 #define protected public
17 #include "bluetooth_call.h"
18 #include "bluetooth_call_client.h"
19 #include "bluetooth_call_connection.h"
20 #include "bluetooth_call_manager.h"
21 #include "bluetooth_call_service.h"
22 #include "bluetooth_call_state.h"
23 #include "bluetooth_connection.h"
24 #include "call_ability_connect_callback.h"
25 #include "call_broadcast_subscriber.h"
26 #include "call_connect_ability.h"
27 #include "call_incoming_filter_manager.h"
28 #include "call_object_manager.h"
29 #include "call_request_event_handler_helper.h"
30 #include "call_status_policy.h"
31 #include "call_superprivacy_control_manager.h"
32 #include "call_wired_headset.h"
33 #include "common_event_manager.h"
34 #include "common_event_support.h"
35 #include "fold_status_manager.h"
36 #include "gtest/gtest.h"
37 #include "ims_call.h"
38 #include "ims_conference.h"
39 #include "ott_call.h"
40 #include "voip_call.h"
41 #include "audio_control_manager.h"
42 #include "call_state_processor.h"
43
44 namespace OHOS {
45 namespace Telephony {
46 using namespace testing::ext;
47 constexpr int WAIT_TIME = 3;
48
49 class ZeroBranch7Test : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp();
54 void TearDown();
55 };
SetUpTestCase()56 void ZeroBranch7Test::SetUpTestCase() {}
57
TearDownTestCase()58 void ZeroBranch7Test::TearDownTestCase() {}
59
SetUp()60 void ZeroBranch7Test::SetUp() {}
61
TearDown()62 void ZeroBranch7Test::TearDown()
63 {
64 sleep(1);
65 }
66
67 /**
68 * @tc.number Telephony_CallBroadcastSubscriber_001
69 * @tc.name test error branch
70 * @tc.desc Function test
71 */
72 HWTEST_F(ZeroBranch7Test, Telephony_CallBroadcastSubscriber_001, TestSize.Level0)
73 {
74 EventFwk::MatchingSkills matchingSkills;
75 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
76 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
77 CallBroadcastSubscriber subscriber(subscriberInfo);
78 EventFwk::CommonEventData eventData;
79 ASSERT_NO_THROW(subscriber.OnReceiveEvent(eventData));
80 ASSERT_NO_THROW(subscriber.UnknownBroadcast(eventData));
81 ASSERT_NO_THROW(subscriber.SimStateBroadcast(eventData));
82 ASSERT_NO_THROW(subscriber.ConnectCallUiServiceBroadcast(eventData));
83 ASSERT_NO_THROW(subscriber.HighTempLevelChangedBroadcast(eventData));
84 ASSERT_NO_THROW(subscriber.ConnectCallUiSuperPrivacyModeBroadcast(eventData));
85 ASSERT_NO_THROW(subscriber.UpdateBluetoothDeviceName(eventData));
86 ASSERT_NO_THROW(subscriber.ConnectCallUiUserSwitchedBroadcast(eventData));
87 ASSERT_NO_THROW(subscriber.ShutdownBroadcast(eventData));
88 ASSERT_NO_THROW(subscriber.HsdrEventBroadcast(eventData));
89 ASSERT_NO_THROW(subscriber.ScreenUnlockedBroadcast(eventData));
90 }
91
92 /**
93 * @tc.number Telephony_CallStatusCallbackStub_008
94 * @tc.name test error branch
95 * @tc.desc Function test
96 */
97 HWTEST_F(ZeroBranch7Test, Telephony_CallStatusCallbackStub_001, TestSize.Level0)
98 {
99 auto callStatusCallback = std::make_shared<CallStatusCallback>();
100 MessageParcel messageParcel;
101 messageParcel.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
102 messageParcel.WriteInt32(0);
103 messageParcel.WriteString("hello");
104 MessageParcel reply;
105 ASSERT_EQ(callStatusCallback->OnUpdateDisconnectedCause(messageParcel, reply), TELEPHONY_SUCCESS);
106 MessageParcel dataParcel2;
107 dataParcel2.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
108 dataParcel2.WriteInt32(0);
109 callStatusCallback->OnUpdateRBTPlayInfo(dataParcel2, reply);
110 callStatusCallback->OnUpdateSetWaitingResult(dataParcel2, reply);
111 callStatusCallback->OnUpdateSetRestrictionResult(dataParcel2, reply);
112 callStatusCallback->OnUpdateSetRestrictionPasswordResult(dataParcel2, reply);
113 callStatusCallback->OnUpdateSetTransferResult(dataParcel2, reply);
114 callStatusCallback->OnUpdateSetCallClirResult(dataParcel2, reply);
115 callStatusCallback->OnStartRttResult(dataParcel2, reply);
116 callStatusCallback->OnStopRttResult(dataParcel2, reply);
117 callStatusCallback->OnSetImsConfigResult(dataParcel2, reply);
118 callStatusCallback->OnSetImsFeatureValueResult(dataParcel2, reply);
119 callStatusCallback->OnInviteToConferenceResult(dataParcel2, reply);
120 callStatusCallback->OnStartDtmfResult(dataParcel2, reply);
121 callStatusCallback->OnStopDtmfResult(dataParcel2, reply);
122 callStatusCallback->OnSendUssdResult(dataParcel2, reply);
123 callStatusCallback->OnGetImsCallDataResult(dataParcel2, reply);
124 ASSERT_EQ(callStatusCallback->OnCloseUnFinishedUssdResult(dataParcel2, reply), TELEPHONY_SUCCESS);
125 }
126
127 /**
128 * @tc.number Telephony_CallStatusCallbackStub_009
129 * @tc.name test error branch
130 * @tc.desc Function test
131 */
132 HWTEST_F(ZeroBranch7Test, Telephony_CallStatusCallbackStub_002, TestSize.Level0)
133 {
134 auto callStatusCallback = std::make_shared<CallStatusCallback>();
135 MessageParcel dataParce3;
136 dataParce3.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
137 int32_t length = sizeof(ClirResponse);
138 dataParce3.WriteInt32(length);
139 ClirResponse clirResponse;
140 dataParce3.WriteRawData((const void *)&clirResponse, length);
141 dataParce3.RewindRead(0);
142 MessageParcel reply;
143 callStatusCallback->OnUpdateGetCallClirResult(dataParce3, reply);
144
145 MessageParcel dataParce4;
146 dataParce4.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
147 length = sizeof(CallModeReportInfo);
148 dataParce4.WriteInt32(length);
149 CallModeReportInfo callModeReportInfo;
150 dataParce4.WriteRawData((const void *)&callModeReportInfo, length);
151 dataParce4.RewindRead(0);
152 callStatusCallback->OnReceiveImsCallModeResponse(dataParce4, reply);
153 MessageParcel dataParce5;
154 dataParce5.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
155 dataParce5.WriteString("a");
156 callStatusCallback->OnPostDialNextChar(dataParce5, reply);
157 callStatusCallback->OnReportPostDialDelay(dataParce5, reply);
158
159 MessageParcel dataParce6;
160 dataParce6.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
161 dataParce6.WriteString("123");
162 dataParce6.WriteString("abc");
163 dataParce6.WriteInt32(0);
164 dataParce6.WriteInt32(0);
165 ASSERT_EQ(callStatusCallback->OnUpdateVoipEventInfo(dataParce6, reply), TELEPHONY_SUCCESS);
166 }
167
168 HWTEST_F(ZeroBranch7Test, Telephony_FoldStatusManager_001, TestSize.Level1)
169 {
170 auto foldStatusManagerPtr = DelayedSingleton<FoldStatusManager>::GetInstance();
171 if (foldStatusManagerPtr == nullptr) {
172 return;
173 }
174 foldStatusManagerPtr->RegisterFoldableListener();
175 foldStatusManagerPtr->UnregisterFoldableListener();
176 FoldStatusManager::IsSmallFoldDevice();
177 FoldStatusManager::FoldStatusListener listenerPtr;
178 listenerPtr.OnFoldStatusChanged(Rosen::FoldStatus::UNKNOWN);
179 listenerPtr.OnFoldStatusChanged(Rosen::FoldStatus::EXPAND);
180 EXPECT_TRUE(foldStatusManagerPtr != nullptr);
181 }
182
183 HWTEST_F(ZeroBranch7Test, Telephony_BluetoothCallConnection_001, TestSize.Level0)
184 {
185 auto blueToothConnectionPtr = DelayedSingleton<BluetoothCallConnection>::GetInstance();
186 if (blueToothConnectionPtr == nullptr) {
187 return;
188 }
189 DialParaInfo info;
190 blueToothConnectionPtr->Dial(info);
191 blueToothConnectionPtr->SetMacAddress("");
192 blueToothConnectionPtr->SetMacAddress("abc");
193 blueToothConnectionPtr->ConnectBtSco();
194 blueToothConnectionPtr->DisConnectBtSco();
195 blueToothConnectionPtr->GetBtScoIsConnected();
196 blueToothConnectionPtr->SetHfpConnected(false);
197 blueToothConnectionPtr->SetHfpConnected(true);
198 blueToothConnectionPtr->GetHfpContactName("");
199 blueToothConnectionPtr->GetHfpContactName("a");
200 blueToothConnectionPtr->SetHfpContactName("a", "b");
201 blueToothConnectionPtr->GetHfpContactName("a");
202 EXPECT_TRUE(blueToothConnectionPtr != nullptr);
203 }
204
205 /**
206 * @tc.number Telephony_CallWiredHeadSet_001
207 * @tc.name test key mute press
208 * @tc.desc Function test
209 */
210 HWTEST_F(ZeroBranch7Test, Telephony_CallWiredHeadSet_001, Function | MediumTest | Level1)
211 {
212 auto instance = DelayedSingleton<CallWiredHeadSet>::GetInstance();
213 instance->UnregistKeyMutePressedUp();
214 instance->UnregistKeyMutePressedDown();
215 DelayedSingleton<AudioDeviceManager>::GetInstance()->isWiredHeadsetConnected_ = false;
216 EXPECT_TRUE(instance->RegistKeyMutePressedUp());
217 EXPECT_TRUE(instance->RegistKeyMutePressedDown());
218 instance->downFirstTime_ = 0;
219 instance->isProcessed_ = true;
220 instance->DealKeyMutePressedDown(nullptr);
221 instance->DealKeyMutePressedUp(nullptr);
222 EXPECT_FALSE(instance->isProcessed_);
223 instance->DealKeyMutePressedDown(nullptr);
224 DelayedSingleton<AudioDeviceManager>::GetInstance()->isWiredHeadsetConnected_ = true;
225 instance->DealKeyMutePressedDown(nullptr);
226 EXPECT_NE(instance->downFirstTime_, 0);
227 instance->DealKeyMutePressedUp(nullptr);
228 instance->DealKeyMutePressedDown(nullptr);
229 instance->DealKeyMutePressedDown(nullptr);
230 sleep(WAIT_TIME);
231 instance->DealKeyMutePressedDown(nullptr);
232 EXPECT_TRUE(instance->isProcessed_);
233 instance->DealKeyMutePressedUp(nullptr);
234 instance->UnregistKeyMutePressedUp();
235 instance->UnregistKeyMutePressedDown();
236 }
237
238
239 static bool g_receiveUnknownEvent = false;
240
UnknownBroadcastStub(const EventFwk::CommonEventData & data)241 static void UnknownBroadcastStub(const EventFwk::CommonEventData &data)
242 {
243 g_receiveUnknownEvent = true;
244 }
245
246 /**
247 * @tc.number Telephony_CallBroadCastSubscriber_002
248 * @tc.name test OnReceiveEvent
249 * @tc.desc Function test
250 */
251 HWTEST_F(ZeroBranch7Test, Telephony_CallBroadCastSubscriber_002, Function | MediumTest | Level1)
252 {
253 g_receiveUnknownEvent = false;
254 EventFwk::MatchingSkills matchingSkills;
255 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
256 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
257 subscriberPtr->memberFuncMap_[CallBroadcastSubscriber::UNKNOWN_BROADCAST_EVENT] =
__anon7958c8750102(const EventFwk::CommonEventData &data) 258 [](const EventFwk::CommonEventData &data) { UnknownBroadcastStub(data); };
259 EventFwk::CommonEventData data;
260 OHOS::EventFwk::Want want;
261 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
262 data.SetWant(want);
263 subscriberPtr->OnReceiveEvent(data);
264 want.SetAction("event.custom.contacts.PAGE_STATE_CHANGE");
265 data.SetWant(want);
266 subscriberPtr->OnReceiveEvent(data);
267 want.SetAction("usual.event.thermal.satcomm.HIGH_TEMP_LEVEL");
268 data.SetWant(want);
269 subscriberPtr->OnReceiveEvent(data);
270 want.SetAction("usual.event.SUPER_PRIVACY_MODE");
271 data.SetWant(want);
272 subscriberPtr->OnReceiveEvent(data);
273 want.SetAction("usual.event.HSDR_EVENT");
274 data.SetWant(want);
275 subscriberPtr->OnReceiveEvent(data);
276 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_NAME_UPDATE);
277 data.SetWant(want);
278 subscriberPtr->OnReceiveEvent(data);
279 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
280 data.SetWant(want);
281 subscriberPtr->OnReceiveEvent(data);
282 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN);
283 data.SetWant(want);
284 subscriberPtr->OnReceiveEvent(data);
285 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED);
286 data.SetWant(want);
287 subscriberPtr->OnReceiveEvent(data);
288 want.SetAction("usual.event.bluetooth.CONNECT_HFP_HF");
289 data.SetWant(want);
290 subscriberPtr->OnReceiveEvent(data);
291 want.SetAction("multimodal.event.MUTE_KEY_PRESS");
292 data.SetWant(want);
293 subscriberPtr->OnReceiveEvent(data);
294 want.SetAction("unknown.event");
295 data.SetWant(want);
296 subscriberPtr->OnReceiveEvent(data);
297 subscriberPtr->memberFuncMap_.clear();
298 subscriberPtr->OnReceiveEvent(data);
299 EXPECT_TRUE(g_receiveUnknownEvent);
300 }
301
302 /**
303 * @tc.number Telephony_CallBroadcastSubscriber_003
304 * @tc.name test ConnectCallUiSuperPrivacyModeBroadcast
305 * @tc.desc Function test
306 */
307 HWTEST_F(ZeroBranch7Test, Telephony_CallBroadcastSubscriber_003, Function | MediumTest | Level1)
308 {
309 EventFwk::MatchingSkills matchingSkills;
310 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
311 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
312 EventFwk::CommonEventData data;
313 OHOS::EventFwk::Want want;
314 want.SetAction("usual.event.SUPER_PRIVACY_MODE");
315 want.SetParam("isInCall", false);
316 want.SetParam("isHangup", true);
317 data.SetWant(want);
318 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->SetIsChangeSuperPrivacyMode(false);
319 subscriberPtr->OnReceiveEvent(data);
320 EXPECT_TRUE(DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->GetIsChangeSuperPrivacyMode());
321 want.SetParam("isInCall", true);
322 want.SetParam("isHangup", false);
323 want.SetParam("isAnswer", true);
324 data.SetWant(want);
325 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->SetIsChangeSuperPrivacyMode(false);
326 subscriberPtr->OnReceiveEvent(data);
327 want.SetParam("isInCall", true);
328 want.SetParam("isHangup", true);
329 data.SetWant(want);
330 subscriberPtr->OnReceiveEvent(data);
331 EXPECT_TRUE(DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->GetIsChangeSuperPrivacyMode());
332 }
333
334 /**
335 * @tc.number Telephony_CallBroadcastSubscriber_004
336 * @tc.name test HfpConnectBroadcast
337 * @tc.desc Function test
338 */
339 HWTEST_F(ZeroBranch7Test, Telephony_CallBroadcastSubscriber_004, Function | MediumTest | Level1)
340 {
341 EventFwk::MatchingSkills matchingSkills;
342 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
343 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
344 EventFwk::CommonEventData data;
345 OHOS::EventFwk::Want want;
346 want.SetAction("usual.event.bluetooth.CONNECT_HFP_HF");
347 std::string contact = "contact";
348 std::string phoneNumber = "123456";
349 want.SetParam("contact", contact);
350 want.SetParam("phoneNumber", phoneNumber);
351 data.SetWant(want);
352 subscriberPtr->OnReceiveEvent(data);
353 DialParaInfo info;
354 sptr<CallBase> alertingCall = new IMSCall(info);
355 alertingCall->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
356 CallObjectManager::AddOneCallObject(alertingCall);
357 subscriberPtr->OnReceiveEvent(data);
358 alertingCall->SetAccountNumber(phoneNumber);
359 subscriberPtr->OnReceiveEvent(data);
360 EXPECT_EQ(DelayedSingleton<BluetoothCallConnection>::GetInstance()->hfpPhoneNumber_, phoneNumber);
361 EXPECT_EQ(DelayedSingleton<BluetoothCallConnection>::GetInstance()->hfpContactName_, contact);
362 CallObjectManager::DeleteOneCallObject(alertingCall);
363 }
364
365 /**
366 * @tc.number Telephony_BluetoothCallState_001
367 * @tc.name test OnConnectionStateChanged & OnScoStateChanged
368 * @tc.desc Function test
369 */
370 HWTEST_F(ZeroBranch7Test, Telephony_BluetoothCallState_001, Function | MediumTest | Level1)
371 {
372 auto bluetoothCallState = std::make_shared<BluetoothCallState>();
373 Bluetooth::BluetoothRemoteDevice device("macAddress");
374 bluetoothCallState->OnConnectionStateChanged(device,
375 static_cast<int32_t>(Bluetooth::BTConnectState::CONNECTED), 0);
376 EXPECT_TRUE(DelayedSingleton<BluetoothCallConnection>::GetInstance()->isHfpConnected_);
377 DelayedSingleton<BluetoothCallConnection>::GetInstance()->hfpPhoneNumber_ = "123";
378 DelayedSingleton<BluetoothCallConnection>::GetInstance()->hfpContactName_ = "456";
379 bluetoothCallState->OnConnectionStateChanged(device,
380 static_cast<int32_t>(Bluetooth::BTConnectState::DISCONNECTED), 0);
381 EXPECT_EQ(DelayedSingleton<BluetoothCallConnection>::GetInstance()->hfpPhoneNumber_, "");
382 EXPECT_EQ(DelayedSingleton<BluetoothCallConnection>::GetInstance()->hfpContactName_, "");
383 bluetoothCallState->OnConnectionStateChanged(device, 1111111, 0);
384 EXPECT_FALSE(DelayedSingleton<BluetoothCallConnection>::GetInstance()->isHfpConnected_);
385 bluetoothCallState->OnScoStateChanged(device, static_cast<int32_t>(Bluetooth::HfpScoConnectState::SCO_CONNECTED));
386 EXPECT_TRUE(DelayedSingleton<BluetoothCallConnection>::GetInstance()->isBtCallScoConnected_);
387 bluetoothCallState->OnScoStateChanged(device,
388 static_cast<int32_t>(Bluetooth::HfpScoConnectState::SCO_DISCONNECTED));
389 EXPECT_FALSE(DelayedSingleton<BluetoothCallConnection>::GetInstance()->isBtCallScoConnected_);
390 }
391
392 /**
393 * @tc.number Telephony_BluetoothCall_001
394 * @tc.name test bluetoothCall
395 * @tc.desc Function test
396 */
397 HWTEST_F(ZeroBranch7Test, Telephony_BluetoothCall_001, Function | MediumTest | Level1)
398 {
399 DialParaInfo info;
400 EXPECT_TRUE(std::make_shared<BluetoothCall>(info, "")->macAddress_.empty());
401 AppExecFwk::PacMap extras;
402 EXPECT_TRUE(std::make_shared<BluetoothCall>(info, extras, "")->macAddress_.empty());
403 EXPECT_FALSE(std::make_shared<BluetoothCall>(info, "macAddress")->macAddress_.empty());
404 EXPECT_FALSE(std::make_shared<BluetoothCall>(info, extras, "macAddress")->macAddress_.empty());
405 EXPECT_GT(std::make_shared<BluetoothCall>(info, "")->AnswerCall(0), TELEPHONY_ERROR);
406 EXPECT_GT(std::make_shared<BluetoothCall>(info, "")->RejectCall(), TELEPHONY_ERROR);
407 EXPECT_GT(std::make_shared<BluetoothCall>(info, "")->HangUpCall(), TELEPHONY_ERROR);
408 EXPECT_GT(std::make_shared<BluetoothCall>(info, "")->StartDtmf('0'), TELEPHONY_ERROR);
409 EXPECT_GT(std::make_shared<BluetoothCall>(info, "macAddress")->AnswerCall(0), TELEPHONY_ERROR);
410 EXPECT_GT(std::make_shared<BluetoothCall>(info, "macAddress")->RejectCall(), TELEPHONY_ERROR);
411 EXPECT_GT(std::make_shared<BluetoothCall>(info, "macAddress")->HangUpCall(), TELEPHONY_ERROR);
412 EXPECT_GT(std::make_shared<BluetoothCall>(info, "macAddress")->StartDtmf('0'), TELEPHONY_ERROR);
413 }
414
415 class MockRemoteObject : public IRemoteObject {
416 public:
MockRemoteObject()417 explicit MockRemoteObject() : IRemoteObject(u"default") {}
418
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)419 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
420 {
421 return 0;
422 }
423
GetObjectRefCount()424 int32_t GetObjectRefCount()
425 {
426 return 0;
427 }
428
AddDeathRecipient(const sptr<DeathRecipient> & recipient)429 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient)
430 {
431 return true;
432 }
433
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)434 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient)
435 {
436 return true;
437 }
438
IsObjectDead() const439 bool IsObjectDead() const
440 {
441 return false;
442 }
443
Dump(int fd,const std::vector<std::u16string> & args)444 int Dump(int fd, const std::vector<std::u16string> &args)
445 {
446 return 0;
447 }
448 };
449
450 /**
451 * @tc.number Telephony_CallAbilityConnectCallback_001
452 * @tc.name test CallAbilityConnectCallback
453 * @tc.desc Function test
454 */
455 HWTEST_F(ZeroBranch7Test, Telephony_CallAbilityConnectCallback_001, Function | MediumTest | Level1)
456 {
457 sptr<IRemoteObject> remoteObject = new MockRemoteObject();
458 auto callback = std::make_shared<CallAbilityConnectCallback>();
459 AppExecFwk::ElementName element;
460 callback->OnAbilityConnectDone(element, remoteObject, -1);
461 DelayedSingleton<CallConnectAbility>::GetInstance()->SetConnectFlag(true);
462 CallObjectManager::callObjectPtrList_.clear();
463 DialParaInfo info;
464 sptr<CallBase> call0 = new IMSCall(info);
465 call0->SetCallId(0);
466 call0->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTING);
467 sptr<CallBase> call1 = new IMSCall(info);
468 call1->SetCallId(1);
469 call1->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTED);
470 sptr<CallBase> call2 = new IMSCall(info);
471 call2->SetCallId(2);
472 call2->SetTelCallState(TelCallState::CALL_STATUS_UNKNOWN);
473 sptr<CallBase> call3 = new IMSCall(info);
474 call3->SetCallId(3);
475 call3->SetTelCallState(TelCallState::CALL_STATUS_IDLE);
476 CallObjectManager::AddOneCallObject(call0);
477 CallObjectManager::AddOneCallObject(call1);
478 CallObjectManager::AddOneCallObject(call2);
479 CallObjectManager::AddOneCallObject(call3);
480 callback->OnAbilityDisconnectDone(element, -1);
481 EXPECT_FALSE(DelayedSingleton<CallConnectAbility>::GetInstance()->GetConnectFlag());
482 CallObjectManager::callObjectPtrList_.clear();
483 }
484
485 /**
486 * @tc.number Telephony_CallConnectAbility_001
487 * @tc.name test CallConnectAbility
488 * @tc.desc Function test
489 */
490 HWTEST_F(ZeroBranch7Test, Telephony_CallConnectAbility_001, Function | MediumTest | Level1)
491 {
492 DelayedSingleton<CallConnectAbility>::GetInstance()->isDisconnecting_ = false;
493 DelayedSingleton<CallConnectAbility>::GetInstance()->isConnected_ = true;
494 DelayedSingleton<CallConnectAbility>::GetInstance()->ConnectAbility();
495 EXPECT_FALSE(DelayedSingleton<CallConnectAbility>::GetInstance()->isConnecting_);
496 DelayedSingleton<CallConnectAbility>::GetInstance()->connectCallback_ = nullptr;
497 DelayedSingleton<CallConnectAbility>::GetInstance()->DisconnectAbility();
498 EXPECT_TRUE(DelayedSingleton<CallConnectAbility>::GetInstance()->isDisconnecting_);
499 DelayedSingleton<CallConnectAbility>::GetInstance()->isConnected_ = false;
500 DelayedSingleton<CallConnectAbility>::GetInstance()->isConnecting_ = true;
501 DelayedSingleton<CallConnectAbility>::GetInstance()->isDisconnecting_ = false;
502 DelayedSingleton<CallConnectAbility>::GetInstance()->SetDisconnectingFlag(false);
503 DelayedSingleton<CallConnectAbility>::GetInstance()->WaitForConnectResult();
504 DelayedSingleton<CallConnectAbility>::GetInstance()->isDisconnecting_ = true;
505 DialParaInfo info;
506 sptr<CallBase> call = new IMSCall(info);
507 CallObjectManager::callObjectPtrList_.clear();
508 CallObjectManager::AddOneCallObject(call);
509 DelayedSingleton<CallConnectAbility>::GetInstance()->SetConnectingFlag(false);
510 EXPECT_FALSE(DelayedSingleton<CallConnectAbility>::GetInstance()->isConnecting_);
511 CallObjectManager::callObjectPtrList_.clear();
512 DelayedSingleton<CallConnectAbility>::GetInstance()->SetConnectingFlag(false);
513 }
514
515 /**
516 * @tc.number Telephony_CallConnectAbility_002
517 * @tc.name test CallConnectAbility
518 * @tc.desc Function test
519 */
520 HWTEST_F(ZeroBranch7Test, Telephony_CallConnectAbility_002, Function | MediumTest | Level1)
521 {
522 DelayedSingleton<CallConnectAbility>::GetInstance()->isDisconnecting_ = false;
523 DelayedSingleton<CallConnectAbility>::GetInstance()->isConnected_ = true;
524 DelayedSingleton<CallConnectAbility>::GetInstance()->connectCallback_ = nullptr;
525 DelayedSingleton<CallConnectAbility>::GetInstance()->DisconnectAbility();
526 EXPECT_TRUE(DelayedSingleton<CallConnectAbility>::GetInstance()->isDisconnecting_);
527
528 DelayedSingleton<CallConnectAbility>::GetInstance()->isDisconnecting_ = false;
529 DelayedSingleton<CallConnectAbility>::GetInstance()->isConnected_ = false;
530 DelayedSingleton<CallConnectAbility>::GetInstance()->ConnectAbility();
531
532 DelayedSingleton<CallConnectAbility>::GetInstance()->isConnecting_ = false;
533 DelayedSingleton<CallConnectAbility>::GetInstance()->isConnected_ = true;
534 DelayedSingleton<CallConnectAbility>::GetInstance()->ConnectAbility();
535 EXPECT_NE(DelayedSingleton<CallConnectAbility>::GetInstance()->connectCallback_, nullptr);
536 }
537
538 /**
539 * @tc.number Telephony_OTTCall_001
540 * @tc.name test OTTCall
541 * @tc.desc Function test
542 */
543 HWTEST_F(ZeroBranch7Test, Telephony_OTTCall_001, Function | MediumTest | Level1)
544 {
545 DialParaInfo info;
546 std::shared_ptr<OTTCall> call = std::make_shared<OTTCall>(info);
547 for (int16_t i = 0; i <= kMaxNumberLen + 1; i++) {
548 call->accountNumber_ += "1";
549 }
550 call->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_RINGING;
551 EXPECT_EQ(call->AnswerCall(0), CALL_ERR_ANSWER_FAILED);
552 EXPECT_EQ(call->RejectCall(), CALL_ERR_REJECT_FAILED);
553 EXPECT_EQ(call->HangUpCall(), CALL_ERR_HANGUP_FAILED);
554 EXPECT_EQ(call->HoldCall(), CALL_ERR_HOLD_FAILED);
555 EXPECT_EQ(call->UnHoldCall(), CALL_ERR_UNHOLD_FAILED);
556 EXPECT_EQ(call->SwitchCall(), CALL_ERR_UNHOLD_FAILED);
557 EXPECT_EQ(call->CombineConference(), CALL_ERR_NUMBER_OUT_OF_RANGE);
558 EXPECT_EQ(call->SeparateConference(), CALL_ERR_NUMBER_OUT_OF_RANGE);
559 EXPECT_EQ(call->KickOutFromConference(), CALL_ERR_NUMBER_OUT_OF_RANGE);
560 call->accountNumber_ = "1111";
561 EXPECT_NE(call->AnswerCall(0), CALL_ERR_NUMBER_OUT_OF_RANGE);
562 EXPECT_NE(call->RejectCall(), CALL_ERR_NUMBER_OUT_OF_RANGE);
563 EXPECT_NE(call->HangUpCall(), CALL_ERR_NUMBER_OUT_OF_RANGE);
564 EXPECT_NE(call->HoldCall(), CALL_ERR_NUMBER_OUT_OF_RANGE);
565 EXPECT_NE(call->UnHoldCall(), CALL_ERR_NUMBER_OUT_OF_RANGE);
566 EXPECT_NE(call->SwitchCall(), CALL_ERR_NUMBER_OUT_OF_RANGE);
567 EXPECT_NE(call->CombineConference(), CALL_ERR_NUMBER_OUT_OF_RANGE);
568 EXPECT_NE(call->SeparateConference(), CALL_ERR_NUMBER_OUT_OF_RANGE);
569 EXPECT_NE(call->KickOutFromConference(), CALL_ERR_NUMBER_OUT_OF_RANGE);
570 call->ottCallConnectionPtr_ = nullptr;
571 EXPECT_EQ(call->AnswerCall(0), TELEPHONY_ERR_LOCAL_PTR_NULL);
572 EXPECT_EQ(call->CombineConference(), TELEPHONY_ERR_LOCAL_PTR_NULL);
573 EXPECT_EQ(call->SeparateConference(), TELEPHONY_ERR_LOCAL_PTR_NULL);
574 EXPECT_EQ(call->KickOutFromConference(), TELEPHONY_ERR_LOCAL_PTR_NULL);
575 for (int16_t i = 0; i <= kMaxBundleNameLen + 1; i++) {
576 call->bundleName_ += "1";
577 }
578 OttCallRequestInfo requestInfo;
579 EXPECT_EQ(call->PackOttCallRequestInfo(requestInfo), CALL_ERR_NUMBER_OUT_OF_RANGE);
580 }
581
582 /**
583 * @tc.number Telephony_CallSuperPrivacyControlManager_001
584 * @tc.name test CallSuperPrivacyControlManager
585 * @tc.desc Function test
586 */
587 HWTEST_F(ZeroBranch7Test, Telephony_CallSuperPrivacyControlManager_001, Function | MediumTest | Level1)
588 {
589 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->ParamChangeCallback(nullptr, "", nullptr);
590 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->ParamChangeCallback("", nullptr, nullptr);
591 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->ParamChangeCallback(nullptr, nullptr, nullptr);
592 DialParaInfo info;
593 info.isEcc = true;
594 sptr<CallBase> call0 = new IMSCall(info);
595 call0->SetCallId(0);
596 call0->isEccContact_ = false;
597 info.isEcc = true;
598 sptr<CallBase> call1 = new IMSCall(info);
599 call1->SetCallId(1);
600 call1->isEccContact_ = true;
601 info.isEcc = false;
602 sptr<CallBase> call2 = new IMSCall(info);
603 call2->SetCallId(2);
604 call2->isEccContact_ = true;
605 info.isEcc = false;
606 sptr<CallBase> call3 = new IMSCall(info);
607 call3->SetCallId(3);
608 call3->isEccContact_ = false;
609 call3->SetTelCallState(TelCallState::CALL_STATUS_WAITING);
610 sptr<CallBase> call4 = new IMSCall(info);
611 call4->SetCallId(4);
612 call4->isEccContact_ = false;
613 call4->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
614 sptr<CallBase> call5 = new IMSCall(info);
615 call5->SetCallId(5);
616 call5->isEccContact_ = false;
617 call5->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTED);
618 CallObjectManager::AddOneCallObject(call0);
619 CallObjectManager::AddOneCallObject(call1);
620 CallObjectManager::AddOneCallObject(call2);
621 CallObjectManager::AddOneCallObject(call3);
622 CallObjectManager::AddOneCallObject(call4);
623 CallObjectManager::AddOneCallObject(call5);
624 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->CloseAllCall();
625 EXPECT_FALSE(DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->GetCurrentIsSuperPrivacyMode());
626 CallObjectManager::callObjectPtrList_.clear();
627 }
628
629 /**
630 * @tc.number Telephony_CallRequestEventHandlerHelper_001
631 * @tc.name test CallRequestEventHandlerHelper
632 * @tc.desc Function test
633 */
634 HWTEST_F(ZeroBranch7Test, Telephony_CallRequestEventHandlerHelper_001, Function | MediumTest | Level1)
635 {
636 auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
637 callRequestEventHandler->pendingHangupCallId_ = 0;
638 callRequestEventHandler->pendingHangup_ = false;
639 EXPECT_FALSE(callRequestEventHandler->IsPendingHangup());
640 EXPECT_EQ(callRequestEventHandler->GetPendingHangupCallId(), -1);
641 callRequestEventHandler->pendingHangup_ = true;
642 EXPECT_EQ(callRequestEventHandler->GetPendingHangupCallId(), 0);
643 }
644
645 /**
646 * @tc.number Telephony_CallBase_001
647 * @tc.name test CallBase
648 * @tc.desc Function test
649 */
650 HWTEST_F(ZeroBranch7Test, Telephony_CallBase_001, Function | MediumTest | Level1)
651 {
652 DialParaInfo info;
653 sptr<CallBase> call0 = new VoIPCall(info);
654 call0->SetCallId(0);
655 call0->SetCallType(CallType::TYPE_VOIP);
656 call0->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
657 sptr<CallBase> call1 = new VoIPCall(info);
658 call1->SetCallId(1);
659 call1->SetCallType(CallType::TYPE_VOIP);
660 call1->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
661 sptr<CallBase> call2 = new VoIPCall(info);
662 call2->SetCallId(2);
663 call2->SetCallType(CallType::TYPE_VOIP);
664 call2->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
665 sptr<CallBase> call3 = new IMSCall(info);
666 call3->SetCallId(3);
667 call3->SetCallType(CallType::TYPE_IMS);
668 CallObjectManager::AddOneCallObject(call0);
669 CallObjectManager::AddOneCallObject(call1);
670 CallObjectManager::AddOneCallObject(call2);
671 CallObjectManager::AddOneCallObject(call3);
672 call3->HangUpVoipCall();
673 call3->conferenceState_ = TelConferenceState::TEL_CONFERENCE_ACTIVE;
674 call3->StateChangesToHolding();
675 EXPECT_EQ(call3->conferenceState_, TelConferenceState::TEL_CONFERENCE_DISCONNECTED);
676 call3->conferenceState_ = TelConferenceState::TEL_CONFERENCE_DISCONNECTING;
677 call3->ringEndTime_ = 0;
678 call3->StateChangesToDisconnected();
679 EXPECT_EQ(call3->conferenceState_, TelConferenceState::TEL_CONFERENCE_DISCONNECTED);
680 call3->conferenceState_ = TelConferenceState::TEL_CONFERENCE_ACTIVE;
681 call3->ringEndTime_ = 0;
682 call3->StateChangesToDisconnected();
683 EXPECT_EQ(call3->conferenceState_, TelConferenceState::TEL_CONFERENCE_DISCONNECTED);
684 call3->conferenceState_ = TelConferenceState::TEL_CONFERENCE_ACTIVE;
685 call3->ringEndTime_ = 1;
686 call3->StateChangesToDisconnecting();
687 EXPECT_EQ(call3->conferenceState_, TelConferenceState::TEL_CONFERENCE_DISCONNECTING);
688 call3->conferenceState_ = TelConferenceState::TEL_CONFERENCE_ACTIVE;
689 call3->StateChangesToDisconnecting();
690 EXPECT_EQ(call3->conferenceState_, TelConferenceState::TEL_CONFERENCE_DISCONNECTING);
691 CallObjectManager::callObjectPtrList_.clear();
692 }
693 } // namespace Telephony
694 } // namespace OHOS
695