1 /*
2 * Copyright (C) 2021-2022 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
16 #define private public
17 #define protected public
18 #include "call_manager_gtest.h"
19
20 #include <gtest/gtest.h>
21 #include <cstring>
22 #include <string>
23
24 #include "antifraud_cloud_service.h"
25 #include "bluetooth_hfp_ag.h"
26 #include "call_manager_connect.h"
27 #include "call_manager_service.h"
28 #include "surface_utils.h"
29 #include "telephony_types.h"
30 #include "voip_call.h"
31 #include "anonymize_adapter.h"
32 #include "antifraud_adapter.h"
33 #include "antifraud_service.h"
34 #include "number_identity_service.h"
35
36 using namespace OHOS::Bluetooth;
37 namespace OHOS {
38 namespace Telephony {
39 using namespace testing::ext;
40 constexpr int16_t SIM2_SLOTID = 1;
41 constexpr int16_t SIM1_SLOTID_NO_CARD = 0;
42 constexpr int16_t RETURN_VALUE_IS_ZERO = 0;
43 constexpr int16_t INVALID_NEGATIVE_ID = -100;
44 constexpr int16_t INVALID_POSITIVE_ID = 100;
45 constexpr int INVALID_DIAL_TYPE = 3;
46 constexpr int WAIT_TIME = 3;
47 constexpr int16_t CAMERA_ROTATION_90 = 90;
48 constexpr int16_t CAMERA_ROTATION_ERROR = 50;
49 constexpr int16_t SLEEP_1000_MS = 1000;
50 constexpr int BASE_TIME_MS = 1000;
51 constexpr int SLEEP_TIME_MS = 50;
52 constexpr int MAX_LIMIT_TIME = 18000;
53 constexpr int16_t SIM1_SLOTID = 0;
54 const std::string PHONE_NUMBER = "0000000000";
55
56 BluetoothCallClient &bluetoothCallClient = DelayedRefSingleton<BluetoothCallClient>::GetInstance();
57 std::unordered_map<int32_t, std::unordered_set<int32_t>> g_callStateMap;
58 int32_t g_newCallId = -1;
59 std::mutex CallInfoManager::mutex_;
60 int16_t CallInfoManager::newCallState_;
61 CallAttributeInfo CallInfoManager::updateCallInfo_;
62 std::unordered_set<int32_t> CallInfoManager::callIdSet_;
63
CallDetailsChange(const CallAttributeInfo & info)64 int32_t CallInfoManager::CallDetailsChange(const CallAttributeInfo &info)
65 {
66 TELEPHONY_LOGI("CallDetailsChange Start");
67 std::lock_guard<std::mutex> lock(mutex_);
68 updateCallInfo_ = info;
69 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
70 TELEPHONY_LOGI("CallDetailsChange new call");
71 callIdSet_.insert(updateCallInfo_.callId);
72 g_newCallId = updateCallInfo_.callId;
73 newCallState_ = (int32_t)updateCallInfo_.callState;
74 std::unordered_set<int32_t> newSet;
75 newSet.clear();
76 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
77 }
78 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
79 return TELEPHONY_SUCCESS;
80 }
81
MeeTimeDetailsChange(const CallAttributeInfo & info)82 int32_t CallInfoManager::MeeTimeDetailsChange(const CallAttributeInfo &info)
83 {
84 TELEPHONY_LOGI("MeeTimeDetailsChange Start");
85 std::lock_guard<std::mutex> lock(mutex_);
86 updateCallInfo_ = info;
87 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
88 TELEPHONY_LOGI("MeeTimeDetailsChange new call");
89 callIdSet_.insert(updateCallInfo_.callId);
90 g_newCallId = updateCallInfo_.callId;
91 newCallState_ = (int32_t)updateCallInfo_.callState;
92 std::unordered_set<int32_t> newSet;
93 newSet.clear();
94 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
95 }
96 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
97 return TELEPHONY_SUCCESS;
98 }
99
HasActiveStatus()100 bool CallInfoManager::HasActiveStatus()
101 {
102 TELEPHONY_LOGI("Waiting for activation !");
103 int sumUseTime = 0;
104 int slipMs = SLEEP_TIME_MS;
105 do {
106 if (!(HasState(g_newCallId, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
107 usleep(slipMs * BASE_TIME_MS);
108 sumUseTime += slipMs;
109 } else {
110 TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
111 return true;
112 }
113 } while (sumUseTime < MAX_LIMIT_TIME);
114 TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
115 return false;
116 }
117
HasState(int callId,int32_t callState)118 bool CallInfoManager::HasState(int callId, int32_t callState)
119 {
120 if (g_callStateMap.find(callId) == g_callStateMap.end()) {
121 return false;
122 }
123 if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
124 return false;
125 }
126 return true;
127 }
128
CallEventChange(const CallEventInfo & info)129 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
130 {
131 return TELEPHONY_SUCCESS;
132 }
133
Init()134 void CallInfoManager::Init()
135 {
136 g_newCallId = -1;
137 updateCallInfo_.speakerphoneOn = -1;
138 updateCallInfo_.startTime = -1;
139 updateCallInfo_.isEcc = -1;
140 updateCallInfo_.accountId = -1;
141 updateCallInfo_.callType = CallType::TYPE_CS;
142 updateCallInfo_.callId = -1;
143 updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
144 updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
145 }
146
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)147 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
148 {
149 int32_t useTimeMs = 0;
150 std::cout << "wait for a few seconds......" << std::endl;
151 while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
152 usleep(slipMs * SLEEP_1000_MS);
153 useTimeMs += slipMs;
154 }
155 std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
156 if (eq) {
157 EXPECT_EQ(updateCallInfo_.callId, targetId);
158 } else {
159 EXPECT_NE(updateCallInfo_.callId, targetId);
160 }
161 }
162
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)163 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
164 {
165 if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
166 return;
167 }
168 int32_t usedTimeMs = 0;
169 std::cout << "wait for a few seconds......" << std::endl;
170 while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
171 usleep(slipMs * SLEEP_1000_MS);
172 usedTimeMs += slipMs;
173 }
174 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
175 std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
176 std::cout << "target call state:" << targetState << std::endl;
177 EXPECT_EQ(callState, targetState);
178 }
179
HangUpCall()180 void CallManagerGtest::HangUpCall()
181 {
182 clientPtr_->HangUpCall(INVALID_CALLID);
183 }
184
185 /********************************************* Test RegisterCallBack() ***********************************************/
186 /**
187 * @tc.number Telephony_CallManager_RegisterCallBack_0100
188 * @tc.name test register callback
189 * @tc.desc Function test
190 */
191 HWTEST_F(CallManagerGtest, Telephony_CallManager_RegisterCallBack_0100, Function | MediumTest | Level3)
192 {
193 AccessToken token;
194 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
195 return;
196 }
197
198 std::unique_ptr<CallManagerCallback> callManagerCallbackPtr = std::make_unique<CallManagerCallBackStub>();
199 if (callManagerCallbackPtr == nullptr) {
200 return;
201 }
202 EXPECT_EQ(CallManagerGtest::clientPtr_->RegisterCallBack(std::move(callManagerCallbackPtr)), RETURN_VALUE_IS_ZERO);
203 }
204
205 /*************************************** Test UnRegisterCallBack() ********************************************/
206 /**
207 * @tc.number Telephony_CallManager_UnRegisterCallBack_0100
208 * @tc.name test register callback
209 * @tc.desc Function test
210 */
211 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnRegisterCallBack_0100, Function | MediumTest | Level3)
212 {
213 AccessToken token;
214 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
215 return;
216 }
217
218 EXPECT_EQ(CallManagerGtest::clientPtr_->UnRegisterCallBack(), RETURN_VALUE_IS_ZERO);
219 }
220
221 /************************************ Test SetCallPreferenceMode() *****************************************/
222 /**
223 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0100
224 * @tc.name test set call preference mode cs voice only
225 * @tc.desc Function test
226 */
227 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0100, Function | MediumTest | Level3)
228 {
229 AccessToken token;
230 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
231 return;
232 }
233
234 int32_t mode = CS_VOICE_ONLY;
235 if (HasSimCard(SIM1_SLOTID)) {
236 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
237 }
238 if (HasSimCard(SIM2_SLOTID)) {
239 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
240 }
241 }
242
243 /**
244 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0200
245 * @tc.name test set call preference mode with error mode
246 * @tc.desc Function test
247 */
248 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0200, Function | MediumTest | Level3)
249 {
250 AccessToken token;
251 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
252 return;
253 }
254
255 int32_t mode = 0;
256 if (HasSimCard(SIM1_SLOTID)) {
257 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
258 }
259 if (HasSimCard(SIM2_SLOTID)) {
260 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
261 }
262 }
263
264 /**
265 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0300
266 * @tc.name test set call preference mode with cs voice prefered
267 * @tc.desc Function test
268 */
269 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0300, Function | MediumTest | Level3)
270 {
271 AccessToken token;
272 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
273 return;
274 }
275
276 int32_t mode = CS_VOICE_PREFERRED;
277 if (HasSimCard(SIM1_SLOTID)) {
278 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
279 }
280 if (HasSimCard(SIM2_SLOTID)) {
281 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
282 }
283 }
284
285 /**
286 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0400
287 * @tc.name test set call preference mode with ims ps voice prefered
288 * @tc.desc Function test
289 */
290 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0400, Function | MediumTest | Level3)
291 {
292 AccessToken token;
293 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
294 return;
295 }
296
297 int32_t mode = IMS_PS_VOICE_PREFERRED;
298 if (HasSimCard(SIM1_SLOTID)) {
299 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
300 }
301 if (HasSimCard(SIM2_SLOTID)) {
302 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
303 }
304 }
305
306 /**
307 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0500
308 * @tc.name test set call preference mode with ims ps voice only
309 * @tc.desc Function test
310 */
311 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0500, Function | MediumTest | Level3)
312 {
313 AccessToken token;
314 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
315 return;
316 }
317
318 int32_t mode = IMS_PS_VOICE_ONLY;
319 if (HasSimCard(SIM1_SLOTID)) {
320 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
321 }
322 if (HasSimCard(SIM2_SLOTID)) {
323 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
324 }
325 }
326
327 /*************************************** Test IsInEmergencyCall() **************************************/
328 /**
329 * @tc.number Telephony_CallManager_IsInEmergencyCall_0100
330 * @tc.name test is in emergency call
331 * @tc.desc Function test
332 */
333 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsInEmergencyCall_0100, Function | MediumTest | Level3)
334 {
335 AccessToken token;
336 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
337 return;
338 }
339 bool enabled = false;
340 EXPECT_EQ(CallManagerGtest::clientPtr_->IsInEmergencyCall(enabled), TELEPHONY_SUCCESS);
341 EXPECT_EQ(enabled, false);
342 }
343
344 /**
345 * @tc.number Telephony_CallManager_IsInEmergencyCall_0200
346 * @tc.name test is in emergency call
347 * @tc.desc Function test
348 */
349 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsInEmergencyCall_0200, Function | MediumTest | Level3)
350 {
351 AccessToken token;
352 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
353 return;
354 }
355 bool enabled = false;
356 EXPECT_EQ(bluetoothCallClient.IsInEmergencyCall(enabled), TELEPHONY_SUCCESS);
357 EXPECT_EQ(enabled, false);
358 }
359
360 /**
361 * @tc.number Telephony_CallManager_IsInEmergencyCall_0300
362 * @tc.name test is in emergency call without permission
363 * @tc.desc Function test
364 */
365 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsInEmergencyCall_0300, Function | MediumTest | Level3)
366 {
367 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
368 return;
369 }
370 bool enabled = false;
371 EXPECT_NE(CallManagerGtest::clientPtr_->IsInEmergencyCall(enabled), TELEPHONY_SUCCESS);
372 EXPECT_EQ(enabled, false);
373 }
374
375 /****************************************** Test MuteRinger() *******************************************/
376 /**
377 * @tc.number Telephony_CallManager_MuteRinger_0100
378 * @tc.name test mute ringer
379 * @tc.desc Function test
380 */
381 HWTEST_F(CallManagerGtest, Telephony_CallManager_MuteRinger_0100, Function | MediumTest | Level3)
382 {
383 AccessToken token;
384 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
385 return;
386 }
387
388 EXPECT_EQ(CallManagerGtest::clientPtr_->MuteRinger(), RETURN_VALUE_IS_ZERO);
389 }
390
391 /********************************************* Test JoinConference() *********************************************/
392 /**
393 * @tc.number Telephony_CallManager_JoinConference_0100
394 * @tc.name test join conference
395 * @tc.desc Function test
396 */
397 HWTEST_F(CallManagerGtest, Telephony_CallManager_JoinConference_0100, Function | MediumTest | Level3)
398 {
399 AccessToken token;
400 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
401 return;
402 }
403 int32_t callId = 1;
404 std::vector<std::u16string> numberList { u"0000000000" };
405 EXPECT_NE(CallManagerGtest::clientPtr_->JoinConference(callId, numberList), RETURN_VALUE_IS_ZERO);
406 }
407
408 /**
409 * @tc.number Telephony_CallManager_JoinConference_0200
410 * @tc.name test join conference with empty numberList
411 * @tc.desc Function test
412 */
413 HWTEST_F(CallManagerGtest, Telephony_CallManager_JoinConference_0200, Function | MediumTest | Level3)
414 {
415 AccessToken token;
416 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
417 return;
418 }
419 int32_t callId = 1;
420 std::vector<std::u16string> numberList;
421 EXPECT_NE(CallManagerGtest::clientPtr_->JoinConference(callId, numberList), CALL_ERR_PHONE_NUMBER_EMPTY);
422 }
423
424 /*********************************** Test ReportOttCallDetailsInfo() ***********************************/
425 /**
426 * @tc.number Telephony_CallManager_ReportOttCallDetailsInfo_0100
427 * @tc.name test report ott call details info
428 * @tc.desc Function test
429 */
430 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportOttCallDetailsInfo_0100, Function | MediumTest | Level3)
431 {
432 AccessToken token;
433 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
434 return;
435 }
436 OttCallDetailsInfo info;
437 const char *number = "000000";
438 memcpy_s(info.phoneNum, kMaxNumberLen, number, strlen(number));
439 const char *bundleName = "com.ohos.tddtest";
440 memcpy_s(info.bundleName, kMaxNumberLen, bundleName, strlen(bundleName));
441 info.callState = TelCallState::CALL_STATUS_DIALING;
442 info.videoState = VideoStateType::TYPE_VOICE;
443 std::vector<OttCallDetailsInfo> ottVec { info };
444 EXPECT_EQ(CallManagerGtest::clientPtr_->ReportOttCallDetailsInfo(ottVec), RETURN_VALUE_IS_ZERO);
445 }
446
447 /**
448 * @tc.number Telephony_CallManager_ReportOttCallDetailsInfo_0200
449 * @tc.name test report ott call details info
450 * @tc.desc Function test
451 */
452 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportOttCallDetailsInfo_0200, Function | MediumTest | Level3)
453 {
454 AccessToken token;
455 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
456 return;
457 }
458 std::vector<OttCallDetailsInfo> ottVec;
459 EXPECT_NE(CallManagerGtest::clientPtr_->ReportOttCallDetailsInfo(ottVec), RETURN_VALUE_IS_ZERO);
460 }
461
462 /************************************* Test ReportOttCallEventInfo() ************************************/
463 /**
464 * @tc.number Telephony_CallManager_ReportOttCallEventInfo_0100
465 * @tc.name test report ott call details info
466 * @tc.desc Function test
467 */
468 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportOttCallEventInfo_0100, Function | MediumTest | Level3)
469 {
470 AccessToken token;
471 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
472 return;
473 }
474 OttCallEventInfo info;
475 info.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
476 char bundlename[] = "com.ohos.tddtest";
477 memcpy_s(info.bundleName, kMaxNumberLen, bundlename, strlen(bundlename));
478 EXPECT_EQ(CallManagerGtest::clientPtr_->ReportOttCallEventInfo(info), RETURN_VALUE_IS_ZERO);
479 }
480
481 /*********************************** Test HasVoiceCapability() ***************************************/
482 /**
483 * @tc.number Telephony_CallManager_HasVoiceCapability_0100
484 * @tc.name test report ott call details info
485 * @tc.desc Function test
486 */
487 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasVoiceCapability_0100, Function | MediumTest | Level3)
488 {
489 AccessToken token;
490 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
491 return;
492 }
493
494 EXPECT_EQ(CallManagerGtest::clientPtr_->HasVoiceCapability(), true);
495 }
496
497 /**
498 * @tc.number Telephony_CallManager_InputDialerSpecialCode_0200
499 * @tc.name test Input Dialer Special Code with unsupport code
500 * @tc.desc Function test
501 */
502 HWTEST_F(CallManagerGtest, Telephony_CallManager_InputDialerSpecialCode_0200, Function | MediumTest | Level3)
503 {
504 AccessToken token;
505 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
506 return;
507 }
508 std::string specialCode = "1234";
509 EXPECT_NE(CallManagerGtest::clientPtr_->InputDialerSpecialCode(specialCode), RETURN_VALUE_IS_ZERO);
510 }
511
512 /**
513 * @tc.number Telephony_CallManager_InputDialerSpecialCode_0300
514 * @tc.name test Input Dialer Special Code without permission
515 * @tc.desc Function test
516 */
517 HWTEST_F(CallManagerGtest, Telephony_CallManager_InputDialerSpecialCode_0300, Function | MediumTest | Level3)
518 {
519 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
520 return;
521 }
522 std::string specialCode = "2846579";
523 EXPECT_NE(CallManagerGtest::clientPtr_->InputDialerSpecialCode(specialCode), RETURN_VALUE_IS_ZERO);
524 }
525
526 /**************************** Test RemoveMissedIncomingCallNotification() ****************************/
527 /**
528 * @tc.number Telephony_CallManager_RemoveMissedIncomingCallNotification_0100
529 * @tc.name test remove missed incoming call and mark as read
530 * @tc.desc Function test
531 */
532 HWTEST_F(
533 CallManagerGtest, Telephony_CallManager_RemoveMissedIncomingCallNotification_0100, Function | MediumTest | Level3)
534 {
535 AccessToken token;
536 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
537 return;
538 }
539 EXPECT_EQ(CallManagerGtest::clientPtr_->RemoveMissedIncomingCallNotification(), RETURN_VALUE_IS_ZERO);
540 }
541
542 /**
543 * @tc.number Telephony_CallManager_RemoveMissedIncomingCallNotification_0200
544 * @tc.name test cancel missed incoming call and mark as read without permission
545 * @tc.desc Function test
546 */
547 HWTEST_F(
548 CallManagerGtest, Telephony_CallManager_RemoveMissedIncomingCallNotification_0200, Function | MediumTest | Level3)
549 {
550 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
551 return;
552 }
553 EXPECT_NE(CallManagerGtest::clientPtr_->RemoveMissedIncomingCallNotification(), RETURN_VALUE_IS_ZERO);
554 }
555
556 /******************************************* Test SetVoIPCallState() ********************************************/
557 /**
558 * @tc.number Telephony_CallManager_SetVoIPCallState_0100
559 * @tc.name input VoIP call state 0 test SetVoIPCallState
560 * @tc.desc Function test
561 */
562 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoIPCallState_0100, Function | MediumTest | Level3)
563 {
564 AccessToken token;
565 int32_t state = 0;
566 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoIPCallState(state), RETURN_VALUE_IS_ZERO);
567 }
568
569 /******************************************* Test SetVoIPCallState() ********************************************/
570 /**
571 * @tc.number Telephony_CallManager_SetVoIPCallState_0200
572 * @tc.name input VoIP call state 1 test SetVoIPCallState
573 * @tc.desc Function test
574 */
575 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoIPCallState_0200, Function | MediumTest | Level3)
576 {
577 AccessToken token;
578 int32_t state = 1;
579 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoIPCallState(state), RETURN_VALUE_IS_ZERO);
580 }
581
582 /******************************************* Test SetVoIPCallState() ********************************************/
583 /**
584 * @tc.number Telephony_CallManager_SetVoIPCallState_0300
585 * @tc.name input VoIP call state 2 test SetVoIPCallState
586 * @tc.desc Function test
587 */
588 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoIPCallState_0300, Function | MediumTest | Level3)
589 {
590 AccessToken token;
591 int32_t state = 2;
592 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoIPCallState(state), RETURN_VALUE_IS_ZERO);
593 }
594
595 /******************************************* Test SetVoIPCallState() ********************************************/
596 /**
597 * @tc.number Telephony_CallManager_SetVoIPCallState_0400
598 * @tc.name input VoIP call state 3 test SetVoIPCallState
599 * @tc.desc Function test
600 */
601 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoIPCallState_0400, Function | MediumTest | Level3)
602 {
603 AccessToken token;
604 int32_t state = 3;
605 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoIPCallState(state), RETURN_VALUE_IS_ZERO);
606 }
607
608 /******************************************* Test GetVoIPCallState() ********************************************/
609 /**
610 * @tc.number Telephony_CallManager_GetVoIPCallState_0100
611 * @tc.name test GetVoIPCallState
612 * @tc.desc Function test
613 */
614 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoIPCallState_0100, Function | MediumTest | Level3)
615 {
616 AccessToken token;
617 int32_t state = -1;
618 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoIPCallState(state), RETURN_VALUE_IS_ZERO);
619 }
620
621 /**
622 * @tc.number Telephony_CallManager_GetVoIPCallState_0200
623 * @tc.name test GetVoIPCallState no permission
624 * @tc.desc Function test
625 */
626 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoIPCallState_0200, Function | MediumTest | Level3)
627 {
628 int32_t state = -1;
629 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoIPCallState(state), RETURN_VALUE_IS_ZERO);
630 }
631
632 /**
633 * @tc.number Telephony_CallControlManager_SetVoIPCallInfo_0300
634 * @tc.name test SetVoIPCallInfo
635 * @tc.desc Function test
636 */
637 HWTEST_F(CallManagerGtest, Telephony_CallControlManager_SetVoIPCallInfo_0300, Function | MediumTest | Level3)
638 {
639 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
640 int32_t callId = 10020;
641 std::string phoneNumber = "12345678901";
642 ASSERT_EQ(callControlManager->SetVoIPCallInfo(callId, static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE),
643 phoneNumber), TELEPHONY_SUCCESS);
644 ASSERT_EQ(callControlManager->SetVoIPCallInfo(callId, static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING),
645 phoneNumber), TELEPHONY_SUCCESS);
646 ASSERT_EQ(callControlManager->SetVoIPCallInfo(callId, static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED),
647 phoneNumber), TELEPHONY_SUCCESS);
648 ASSERT_EQ(callControlManager->SetVoIPCallInfo(callId, static_cast<int32_t>(TelCallState::CALL_STATUS_ALERTING),
649 phoneNumber), TELEPHONY_SUCCESS);
650 int32_t state = 5;
651 ASSERT_EQ(callControlManager->GetVoIPCallInfo(callId, state, phoneNumber), TELEPHONY_SUCCESS);
652 }
653
654 /**
655 * @tc.number Telephony_CallManagerServiceStub_SetVoIPCallInfo_0400
656 * @tc.name test SetVoIPCallInfo
657 * @tc.desc Function test
658 */
659 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_SetVoIPCallInfo_0400, Function | MediumTest | Level3)
660 {
661 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
662 MessageParcel data;
663 MessageParcel reply;
664 int32_t callId = 0;
665 data.WriteInt32(callId);
666 data.RewindRead(0);
667 ASSERT_EQ(callManagerService->OnSetVoIPCallInfo(data, reply), TELEPHONY_SUCCESS);
668 ASSERT_EQ(callManagerService->OnGetVoIPCallInfo(data, reply), TELEPHONY_SUCCESS);
669 }
670
671 /*********************************** Test Dump() ***************************************/
672 /**
673 * @tc.number Telephony_CallManager_TestDump_0100
674 * @tc.name Test Dump
675 * @tc.desc Function test
676 */
677 HWTEST_F(CallManagerGtest, Telephony_CallManager_TestDump_0100, Function | MediumTest | Level3)
678 {
679 std::vector<std::u16string> emptyArgs = {};
680 std::vector<std::u16string> args = { u"test", u"test1" };
681 EXPECT_GE(DelayedSingleton<CallManagerService>::GetInstance()->Dump(-1, args), 0);
682 EXPECT_GE(DelayedSingleton<CallManagerService>::GetInstance()->Dump(0, emptyArgs), 0);
683 EXPECT_GE(DelayedSingleton<CallManagerService>::GetInstance()->Dump(0, args), 0);
684 }
685
686 /**
687 * @tc.number Telephony_VoipCallObject_0200
688 * @tc.name Test VoipCallObject
689 * @tc.desc Function test
690 */
691 HWTEST_F(CallManagerGtest, Telephony_VoipCallObject_0200, Function | MediumTest | Level3)
692 {
693 CallObjectManager::ClearVoipList();
694 int32_t callId = 10010;
695 int32_t secondCallId = 10011;
696 CallAttributeInfo callAttrInfo;
697 callAttrInfo.callId = callId;
698 CallAttributeInfo secondCallAttrInfo;
699 secondCallAttrInfo.callId = secondCallId;
700 EXPECT_EQ(CallObjectManager::AddOneVoipCallObject(callAttrInfo), TELEPHONY_SUCCESS);
701
702 EXPECT_EQ(CallObjectManager::AddOneVoipCallObject(secondCallAttrInfo), TELEPHONY_SUCCESS);
703
704 EXPECT_EQ(CallObjectManager::AddOneVoipCallObject(callAttrInfo), CALL_ERR_PHONE_CALL_ALREADY_EXISTS);
705
706 TelCallState nextState = TelCallState::CALL_STATUS_DISCONNECTED;
707 EXPECT_EQ(CallObjectManager::UpdateOneVoipCallObjectByCallId(secondCallId, nextState), TELEPHONY_SUCCESS);
708
709 int32_t newCallId = -1;
710 EXPECT_EQ(CallObjectManager::UpdateOneVoipCallObjectByCallId(newCallId, nextState), TELEPHONY_ERROR);
711
712 EXPECT_EQ(CallObjectManager::DeleteOneVoipCallObject(newCallId), TELEPHONY_ERROR);
713
714 EXPECT_TRUE(CallObjectManager::IsVoipCallExist());
715
716 CallObjectManager::ClearVoipList();
717
718 EXPECT_FALSE(CallObjectManager::IsVoipCallExist());
719 }
720
721 /**
722 * @tc.number Telephony_AntiFraudCloudService_0001
723 * @tc.name Test antiFraud cloud service
724 * @tc.desc Function test
725 */
726 HWTEST_F(CallManagerGtest, Telephony_AntiFraudCloudService_0001, Function | MediumTest | Level3)
727 {
728 auto service = std::make_shared<AntiFraudCloudService>("10000");
729 std::string fileContent = "abcdefghij";
730 OHOS::AntiFraudService::AntiFraudResult antiFraudResult = {0, true, 0, 0, fileContent, 1.0f};
731 EXPECT_FALSE(service->UploadPostRequest(antiFraudResult));
732 EXPECT_TRUE(service->EncryptSync("", nullptr).first.empty());
733 EXPECT_TRUE(service->ProcessEncryptResult("{\"key\":\"value\"}").first.empty());
734 EXPECT_TRUE(service->ProcessEncryptResult("{\"ak\":0}").first.empty());
735 EXPECT_EQ(service->ProcessEncryptResult("{\"ak\":\"ak\"}").first, "ak");
736 EXPECT_TRUE(service->ProcessEncryptResult("{\"ak\":\"ak\"}").second.empty());
737 EXPECT_TRUE(service->ProcessEncryptResult("{\"ak\":\"ak\",\"data\":0}").second.empty());
738 EXPECT_EQ(service->ProcessEncryptResult("{\"ak\":\"ak\",\"data\":\"data\"}").second, "data");
739 EXPECT_TRUE(service->GetAuthSync("", "", nullptr).empty());
740 EXPECT_TRUE(service->ProcessSignResult("").empty());
741 EXPECT_TRUE(service->ProcessSignResult("{\"key\":\"value\"}").empty());
742 EXPECT_TRUE(service->ProcessSignResult("{\"data\":0}").empty());
743 EXPECT_EQ(service->ProcessSignResult("{\"data\":\"data\"}"), "data");
744 auto headers = service->GenerateHeadersMap("", "", "");
745 EXPECT_FALSE(headers.empty());
746 EXPECT_EQ(service->CalculateDigest("abcdefghij"),
747 "72399361da6a7754fec986dca5b7cbaf1c810a28ded4abaf56b2106d06cb78b0");
748 EXPECT_FALSE(service->GenerateRequestJson(headers, "").empty());
749 EXPECT_FALSE(service->GetDeviceSerial().empty());
750 EXPECT_EQ(service->GetSubstringBeforeSymbol("1234", "."), "1234");
751 }
752
753 constexpr int UCS_SERVICE_COMMAND = 0;
754 constexpr int CLOUD_CONNECT_SERVICE_COMMAND = 1;
755 class MockRemoteObject : public IRemoteObject {
756 public:
MockRemoteObject(int command)757 explicit MockRemoteObject(int command) : IRemoteObject(u"default")
758 {
759 command_ = command;
760 }
761
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)762 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
763 {
764 if (command_ == -1) {
765 return -1;
766 }
767 reply.WriteInt32(0);
768 if (command_ == UCS_SERVICE_COMMAND) {
769 std::vector<std::u16string> responseBuffer{u"0"};
770 reply.WriteString16Vector(responseBuffer);
771 }
772 return 0;
773 }
774
GetObjectRefCount()775 int32_t GetObjectRefCount()
776 {
777 return 0;
778 }
779
AddDeathRecipient(const sptr<DeathRecipient> & recipient)780 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient)
781 {
782 return true;
783 }
784
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)785 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient)
786 {
787 return true;
788 }
789
IsObjectDead() const790 bool IsObjectDead() const
791 {
792 return command_ != UCS_SERVICE_COMMAND && command_ != CLOUD_CONNECT_SERVICE_COMMAND;
793 }
794
Dump(int fd,const std::vector<std::u16string> & args)795 int Dump(int fd, const std::vector<std::u16string> &args)
796 {
797 return 0;
798 }
799 private:
800 int command_;
801 };
802
803 /**
804 * @tc.number Telephony_AntiFraudCloudService_0002
805 * @tc.name Test antiFraud cloud service
806 * @tc.desc Function test
807 */
808 HWTEST_F(CallManagerGtest, Telephony_AntiFraudCloudService_0002, Function | MediumTest | Level3)
809 {
810 auto service = std::make_shared<AntiFraudCloudService>("10000");
811 sptr<OHOS::IRemoteObject> failRemoteObj = new MockRemoteObject(-1);
812 EXPECT_FALSE(service->GetAuthSync("", "", failRemoteObj).empty());
813 sptr<OHOS::IRemoteObject> ucsRemoteObj = new MockRemoteObject(UCS_SERVICE_COMMAND);
814 EXPECT_FALSE(service->GetAuthSync("", "", ucsRemoteObj).empty());
815 sptr<OHOS::IRemoteObject> cloudConnectRemoteObj = new MockRemoteObject(CLOUD_CONNECT_SERVICE_COMMAND);
816 OHOS::AntiFraudService::AntiFraudResult antiFraudResult = {0, true, 0, 0, "fileContent", 1.0f};
817 EXPECT_FALSE(service->ConnectCloudAsync("", "", antiFraudResult, nullptr));
818 EXPECT_FALSE(service->ConnectCloudAsync("", "", antiFraudResult, failRemoteObj));
819 EXPECT_TRUE(service->ConnectCloudAsync("", "", antiFraudResult, cloudConnectRemoteObj));
820 }
821
822 /**
823 * @tc.number Telephony_AntiFraudHsdrHelper_0001
824 * @tc.name Test antiFraud hsdr helper
825 * @tc.desc Function test
826 */
827 HWTEST_F(CallManagerGtest, Telephony_AntiFraudHsdrHelper_0001, Function | MediumTest | Level3)
828 {
829 sptr<HsdrConnection> connection = new (std::nothrow) HsdrConnection(
__anon6f36c9840102(const sptr<IRemoteObject> &remoteObject) 830 [](const sptr<IRemoteObject> &remoteObject) {});
831 if (connection == nullptr) {
832 std::cout << "connection is nullptr" << std::endl;
833 return;
834 }
835 AppExecFwk::ElementName element;
836 sptr<OHOS::IRemoteObject> failRemoteObj = new MockRemoteObject(-1);
837 connection->OnAbilityConnectDone(element, failRemoteObj, -1);
838 EXPECT_EQ(connection->remoteObject_, nullptr);
839 connection->OnAbilityConnectDone(element, nullptr, 0);
840 EXPECT_EQ(connection->remoteObject_, nullptr);
841 EXPECT_FALSE(connection->IsAlive());
842 connection->OnAbilityConnectDone(element, failRemoteObj, 0);
843 EXPECT_NE(connection->remoteObject_, nullptr);
844 EXPECT_FALSE(connection->IsAlive());
845 connection->OnAbilityDisconnectDone(element, 0);
846 EXPECT_EQ(connection->remoteObject_, nullptr);
847 sptr<OHOS::IRemoteObject> ucsRemoteObj = new MockRemoteObject(UCS_SERVICE_COMMAND);
848 connection->remoteObject_ = ucsRemoteObj;
849 EXPECT_TRUE(connection->IsAlive());
850 connection->OnAbilityDisconnectDone(element, -1);
851 EXPECT_EQ(connection->remoteObject_, nullptr);
852 connection->connectedCallback_ = nullptr;
853 connection->OnAbilityConnectDone(element, failRemoteObj, 0);
854 EXPECT_EQ(connection->remoteObject_, nullptr);
855 }
856
857 /**
858 * @tc.number Telephony_AntiFraudHsdrHelper_0002
859 * @tc.name Test antiFraud hsdr helper
860 * @tc.desc Function test
861 */
862 HWTEST_F(CallManagerGtest, Telephony_AntiFraudHsdrHelper_0002, Function | MediumTest | Level3)
863 {
__anon6f36c9840202(const HsdrResponse &response) 864 OnResponse onResponse = [](const HsdrResponse &response) {};
__anon6f36c9840302(int errCode) 865 OnError onError = [](int errCode) {};
866 sptr<HsdrCallbackStub> callbackStub =
867 new (std::nothrow) HsdrCallbackStub("123456", onResponse, onError);
868 if (callbackStub == nullptr) {
869 std::cout << "callbackStub is nullptr" << std::endl;
870 return;
871 }
872 MessageParcel data;
873 MessageParcel reply;
874 MessageOption option;
875 EXPECT_NE(callbackStub->OnRemoteRequest(0, data, reply, option), 0);
876 data.WriteInterfaceToken(u"");
877 EXPECT_NE(callbackStub->OnRemoteRequest(0, data, reply, option), 0);
878
879 data.WriteInterfaceToken(u"OHOS.Security.CloudConnectCallback");
880 EXPECT_NE(callbackStub->OnRemoteRequest(0, data, reply, option), 0);
881
882 data.WriteInterfaceToken(u"OHOS.Security.CloudConnectCallback");
883 data.WriteString16(u"123456");
884 std::vector<std::u16string> responseBuffer{u"0"};
885 data.WriteString16Vector(responseBuffer);
886 EXPECT_EQ(callbackStub->OnRemoteRequest(0, data, reply, option), 0);
887
888 MessageParcel data2;
889 data2.WriteInterfaceToken(u"OHOS.Security.CloudConnectCallback");
890 data2.WriteString16(u"1234567");
891 data2.WriteString16Vector(responseBuffer);
892 EXPECT_EQ(callbackStub->OnRemoteRequest(0, data2, reply, option), 0);
893 }
894
895 /**
896 * @tc.number Telephony_AntiFraud_0100
897 * @tc.name Test AntiFraud
898 * @tc.desc Function test
899 */
900 HWTEST_F(CallManagerGtest, Telephony_AntiFraud_0100, Function | MediumTest | Level3)
901 {
902 auto antiFraudService = DelayedSingleton<AntiFraudService>::GetInstance();
903 EXPECT_EQ(antiFraudService->CreateDataShareHelper(-1, USER_SETTINGSDATA_URI.c_str()), nullptr);
904 EXPECT_NE(antiFraudService->CreateDataShareHelper(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID,
905 USER_SETTINGSDATA_URI.c_str()), nullptr);
906
907 std::string switchName = "noswitch";
908 EXPECT_FALSE(antiFraudService->IsSwitchOn(switchName));
909 EXPECT_FALSE(antiFraudService->IsSwitchOn(ANTIFRAUD_SWITCH));
910
911 OHOS::AntiFraudService::AntiFraudResult fraudResult;
912 std::string phoneNum = "123456";
913 antiFraudService->stoppedSlotId_ = 0;
914 antiFraudService->stoppedIndex_ = 0;
915 antiFraudService->RecordDetectResult(fraudResult, phoneNum, 1, 1);
916 EXPECT_EQ(antiFraudService->antiFraudState_, 3);
917 antiFraudService->RecordDetectResult(fraudResult, phoneNum, 0, 1);
918 EXPECT_EQ(antiFraudService->antiFraudState_, 3);
919
920 fraudResult.result = true;
921 antiFraudService->RecordDetectResult(fraudResult, phoneNum, 1, 0);
922 EXPECT_EQ(antiFraudService->antiFraudState_, 2);
923 antiFraudService->RecordDetectResult(fraudResult, phoneNum, 0, 0);
924 EXPECT_EQ(antiFraudService->stoppedIndex_, -1);
925
926 EXPECT_NE(antiFraudService->CheckAntiFraudService(phoneNum, 0, 0), 0);
927 EXPECT_NE(antiFraudService->StartAntiFraudService(phoneNum, 0, 0), 0);
928 EXPECT_NE(antiFraudService->StopAntiFraudService(0, 0), 0);
929
930 auto antiFraudAdapter = DelayedSingleton<AntiFraudAdapter>::GetInstance();
931 antiFraudAdapter->DetectAntiFraud(nullptr);
932 antiFraudAdapter->ReleaseAntiFraud();
933 EXPECT_EQ(antiFraudAdapter->libAntiFraud_, nullptr);
934 }
935 } // namespace Telephony
936 } // namespace OHOS
937