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 "bluetooth_hfp_ag.h"
25 #include "call_manager_connect.h"
26 #include "call_manager_service.h"
27 #include "surface_utils.h"
28 #include "telephony_types.h"
29 #include "voip_call.h"
30 
31 using namespace OHOS::Bluetooth;
32 namespace OHOS {
33 namespace Telephony {
34 using namespace testing::ext;
35 constexpr int16_t SIM2_SLOTID = 1;
36 constexpr int16_t SIM1_SLOTID_NO_CARD = 0;
37 constexpr int16_t RETURN_VALUE_IS_ZERO = 0;
38 constexpr int16_t INVALID_NEGATIVE_ID = -100;
39 constexpr int16_t INVALID_POSITIVE_ID = 100;
40 constexpr int INVALID_DIAL_TYPE = 3;
41 constexpr int WAIT_TIME = 3;
42 constexpr int16_t CAMERA_ROTATION_90 = 90;
43 constexpr int16_t CAMERA_ROTATION_ERROR = 50;
44 constexpr int16_t SLEEP_1000_MS = 1000;
45 constexpr int BASE_TIME_MS = 1000;
46 constexpr int SLEEP_TIME_MS = 50;
47 constexpr int MAX_LIMIT_TIME = 18000;
48 constexpr int16_t SIM1_SLOTID = 0;
49 const std::string PHONE_NUMBER = "0000000000";
50 
51 std::unordered_map<int32_t, std::unordered_set<int32_t>> g_callStateMap;
52 int32_t g_newCallId = -1;
53 std::mutex CallInfoManager::mutex_;
54 int16_t CallInfoManager::newCallState_;
55 CallAttributeInfo CallInfoManager::updateCallInfo_;
56 std::unordered_set<int32_t> CallInfoManager::callIdSet_;
57 
CallDetailsChange(const CallAttributeInfo & info)58 int32_t CallInfoManager::CallDetailsChange(const CallAttributeInfo &info)
59 {
60     TELEPHONY_LOGI("CallDetailsChange Start");
61     std::lock_guard<std::mutex> lock(mutex_);
62     updateCallInfo_ = info;
63     if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
64         TELEPHONY_LOGI("CallDetailsChange new call");
65         callIdSet_.insert(updateCallInfo_.callId);
66         g_newCallId = updateCallInfo_.callId;
67         newCallState_ = (int32_t)updateCallInfo_.callState;
68         std::unordered_set<int32_t> newSet;
69         newSet.clear();
70         g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
71     }
72     g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
73     return TELEPHONY_SUCCESS;
74 }
75 
HasActiveStatus()76 bool CallInfoManager::HasActiveStatus()
77 {
78     TELEPHONY_LOGI("Waiting for activation !");
79     int sumUseTime = 0;
80     int slipMs = SLEEP_TIME_MS;
81     do {
82         if (!(HasState(g_newCallId, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
83             usleep(slipMs * BASE_TIME_MS);
84             sumUseTime += slipMs;
85         } else {
86             TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
87             return true;
88         }
89     } while (sumUseTime < MAX_LIMIT_TIME);
90     TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
91     return false;
92 }
93 
HasState(int callId,int32_t callState)94 bool CallInfoManager::HasState(int callId, int32_t callState)
95 {
96     if (g_callStateMap.find(callId) == g_callStateMap.end()) {
97         return false;
98     }
99     if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
100         return false;
101     }
102     return true;
103 }
104 
CallEventChange(const CallEventInfo & info)105 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
106 {
107     return TELEPHONY_SUCCESS;
108 }
109 
Init()110 void CallInfoManager::Init()
111 {
112     g_newCallId = -1;
113     updateCallInfo_.speakerphoneOn = -1;
114     updateCallInfo_.startTime = -1;
115     updateCallInfo_.isEcc = -1;
116     updateCallInfo_.accountId = -1;
117     updateCallInfo_.callType = CallType::TYPE_CS;
118     updateCallInfo_.callId = -1;
119     updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
120     updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
121 }
122 
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)123 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
124 {
125     int32_t useTimeMs = 0;
126     std::cout << "wait for a few seconds......" << std::endl;
127     while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
128         usleep(slipMs * SLEEP_1000_MS);
129         useTimeMs += slipMs;
130     }
131     std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
132     if (eq) {
133         EXPECT_EQ(updateCallInfo_.callId, targetId);
134     } else {
135         EXPECT_NE(updateCallInfo_.callId, targetId);
136     }
137 }
138 
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)139 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
140 {
141     if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
142         return;
143     }
144     int32_t usedTimeMs = 0;
145     std::cout << "wait for a few seconds......" << std::endl;
146     while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
147         usleep(slipMs * SLEEP_1000_MS);
148         usedTimeMs += slipMs;
149     }
150     int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
151     std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
152     std::cout << "target call state:" << targetState << std::endl;
153     EXPECT_EQ(callState, targetState);
154 }
155 
HangUpCall()156 void CallManagerGtest::HangUpCall()
157 {
158     clientPtr_->HangUpCall(INVALID_CALLID);
159 }
160 
161 class ClientErrorBranchTest : public testing::Test {
162 public:
SetUpTestCase()163     static void SetUpTestCase() {};
TearDownTestCase()164     static void TearDownTestCase() {};
SetUp()165     void SetUp() {};
TearDown()166     void TearDown() {};
167 };
168 
169 /**
170  * @tc.number   Telephony_CallManagerClient_001
171  * @tc.name     test error nullptr branch
172  * @tc.desc     Function test
173  */
174 HWTEST_F(ClientErrorBranchTest, Telephony_CallManagerClient_001, Function | MediumTest | Level3)
175 {
176     std::shared_ptr<CallManagerClient> client = std::make_shared<CallManagerClient>();
177     std::u16string str = u"";
178     client->UnInit();
179     ASSERT_EQ(client->RegisterCallBack(nullptr), TELEPHONY_ERR_UNINIT);
180     ASSERT_EQ(client->UnRegisterCallBack(), TELEPHONY_ERR_UNINIT);
181     ASSERT_EQ(client->ObserverOnCallDetailsChange(), TELEPHONY_ERR_UNINIT);
182     AppExecFwk::PacMap extras;
183     ASSERT_EQ(client->DialCall(str, extras), TELEPHONY_ERR_UNINIT);
184     ASSERT_EQ(client->AnswerCall(g_newCallId, 1), TELEPHONY_ERR_UNINIT);
185     ASSERT_EQ(client->RejectCall(g_newCallId, false, str), TELEPHONY_ERR_UNINIT);
186     ASSERT_EQ(client->HangUpCall(g_newCallId), TELEPHONY_ERR_UNINIT);
187     ASSERT_EQ(client->GetCallState(), TELEPHONY_ERR_UNINIT);
188     ASSERT_EQ(client->RegisterVoipCallManagerCallback(), TELEPHONY_ERR_UNINIT);
189     ASSERT_EQ(client->UnRegisterVoipCallManagerCallback(), TELEPHONY_ERR_UNINIT);
190     ASSERT_EQ(client->HoldCall(g_newCallId), TELEPHONY_ERR_UNINIT);
191     ASSERT_EQ(client->UnHoldCall(g_newCallId), TELEPHONY_ERR_UNINIT);
192     ASSERT_EQ(client->SwitchCall(g_newCallId), TELEPHONY_ERR_UNINIT);
193     ASSERT_EQ(client->CombineConference(g_newCallId), TELEPHONY_ERR_UNINIT);
194     ASSERT_EQ(client->SeparateConference(g_newCallId), TELEPHONY_ERR_UNINIT);
195     ASSERT_EQ(client->KickOutFromConference(g_newCallId), TELEPHONY_ERR_UNINIT);
196     int callId = 1;
197     ASSERT_EQ(client->GetMainCallId(callId, callId), TELEPHONY_ERR_UNINIT);
198     std::vector<std::u16string> callIdList;
199     ASSERT_EQ(client->GetSubCallIdList(g_newCallId, callIdList), TELEPHONY_ERR_UNINIT);
200     ASSERT_EQ(client->GetCallIdListForConference(g_newCallId, callIdList), TELEPHONY_ERR_UNINIT);
201     ASSERT_EQ(client->GetCallWaiting(SIM1_SLOTID), TELEPHONY_ERR_UNINIT);
202     ASSERT_EQ(client->SetCallWaiting(SIM1_SLOTID, false), TELEPHONY_ERR_UNINIT);
203     ASSERT_EQ(client->GetCallRestriction(SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
204         TELEPHONY_ERR_UNINIT);
205     CallRestrictionInfo callRestrictionInfo;
206     ASSERT_EQ(client->SetCallRestriction(SIM1_SLOTID, callRestrictionInfo), TELEPHONY_ERR_UNINIT);
207     ASSERT_EQ(client->SetCallRestrictionPassword(SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
208         "", ""), TELEPHONY_ERR_UNINIT);
209     ASSERT_EQ(client->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY), TELEPHONY_ERR_UNINIT);
210     CallTransferInfo callTransferInfo;
211     ASSERT_EQ(client->SetCallTransferInfo(SIM1_SLOTID, callTransferInfo), TELEPHONY_ERR_UNINIT);
212     bool boolValue = false;
213     ASSERT_EQ(client->CanSetCallTransferTime(SIM1_SLOTID, boolValue), TELEPHONY_ERR_UNINIT);
214     ASSERT_EQ(client->SetCallPreferenceMode(SIM1_SLOTID, 0), TELEPHONY_ERR_UNINIT);
215     ASSERT_EQ(client->StartDtmf(g_newCallId, 'c'), TELEPHONY_ERR_UNINIT);
216     ASSERT_EQ(client->StopDtmf(g_newCallId), TELEPHONY_ERR_UNINIT);
217     ASSERT_EQ(client->PostDialProceed(SIM1_SLOTID, true), TELEPHONY_ERR_UNINIT);
218     ASSERT_EQ(client->IsRinging(boolValue), TELEPHONY_ERR_UNINIT);
219     ASSERT_FALSE(client->HasCall());
220     ASSERT_EQ(client->CancelCallUpgrade(g_newCallId), TELEPHONY_ERR_UNINIT);
221 }
222 
223 /**
224  * @tc.number   Telephony_CallManagerClient_002
225  * @tc.name     test error nullptr branch
226  * @tc.desc     Function test
227  */
228 HWTEST_F(ClientErrorBranchTest, Telephony_CallManagerClient_002, Function | MediumTest | Level3)
229 {
230     std::shared_ptr<CallManagerClient> client = std::make_shared<CallManagerClient>();
231     std::u16string str = u"";
232     bool boolValue = false;
233     int value = 0;
234     ASSERT_EQ(client->IsNewCallAllowed(boolValue), TELEPHONY_ERR_UNINIT);
235     ASSERT_EQ(client->IsInEmergencyCall(boolValue), TELEPHONY_ERR_UNINIT);
236     ASSERT_EQ(client->IsEmergencyPhoneNumber(str, SIM1_SLOTID, boolValue), TELEPHONY_ERR_UNINIT);
237     ASSERT_EQ(client->FormatPhoneNumber(str, str, str), TELEPHONY_ERR_UNINIT);
238     ASSERT_EQ(client->FormatPhoneNumberToE164(str, str, str), TELEPHONY_ERR_UNINIT);
239     ASSERT_EQ(client->SetMuted(false), TELEPHONY_ERR_UNINIT);
240     ASSERT_EQ(client->MuteRinger(), TELEPHONY_ERR_UNINIT);
241     AudioDevice audioDevice;
242     ASSERT_EQ(client->SetAudioDevice(audioDevice), TELEPHONY_ERR_UNINIT);
243     ASSERT_EQ(client->ControlCamera(g_newCallId, str), TELEPHONY_ERR_UNINIT);
244     std::string surfaceId = "";
245     ASSERT_EQ(client->SetPreviewWindow(g_newCallId, surfaceId), TELEPHONY_ERR_UNINIT);
246     ASSERT_EQ(client->SetDisplayWindow(g_newCallId, surfaceId), TELEPHONY_ERR_UNINIT);
247     float zoomRatio = 1.0;
248     ASSERT_EQ(client->SetCameraZoom(zoomRatio), TELEPHONY_ERR_UNINIT);
249     ASSERT_EQ(client->SetPausePicture(g_newCallId, str), TELEPHONY_ERR_UNINIT);
250     ASSERT_EQ(client->SetDeviceDirection(g_newCallId, value), TELEPHONY_ERR_UNINIT);
251     ASSERT_EQ(client->GetImsConfig(SIM1_SLOTID, ITEM_VIDEO_QUALITY), TELEPHONY_ERR_UNINIT);
252     ASSERT_EQ(client->SetImsConfig(SIM1_SLOTID, ITEM_VIDEO_QUALITY, str), TELEPHONY_ERR_UNINIT);
253     ASSERT_EQ(client->GetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_SS_OVER_UT), TELEPHONY_ERR_UNINIT);
254     ASSERT_EQ(client->SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_SS_OVER_UT, value), TELEPHONY_ERR_UNINIT);
255     ASSERT_EQ(client->UpdateImsCallMode(SIM1_SLOTID, CALL_MODE_SEND_ONLY), TELEPHONY_ERR_UNINIT);
256     ASSERT_EQ(client->EnableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_UNINIT);
257     ASSERT_EQ(client->DisableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_UNINIT);
258     ASSERT_EQ(client->IsImsSwitchEnabled(SIM1_SLOTID, boolValue), TELEPHONY_ERR_UNINIT);
259     ASSERT_EQ(client->SetVoNRState(SIM1_SLOTID, value), TELEPHONY_ERR_UNINIT);
260     ASSERT_EQ(client->GetVoNRState(SIM1_SLOTID, value), TELEPHONY_ERR_UNINIT);
261     ASSERT_EQ(client->StartRtt(g_newCallId, str), TELEPHONY_ERR_UNINIT);
262     ASSERT_EQ(client->StopRtt(g_newCallId), TELEPHONY_ERR_UNINIT);
263     std::vector<std::u16string> numberList;
264     ASSERT_EQ(client->JoinConference(g_newCallId, numberList), TELEPHONY_ERR_UNINIT);
265     std::vector<OttCallDetailsInfo> ottVec;
266     ASSERT_EQ(client->ReportOttCallDetailsInfo(ottVec), TELEPHONY_ERR_UNINIT);
267     OttCallEventInfo eventInfo;
268     ASSERT_EQ(client->ReportOttCallEventInfo(eventInfo), TELEPHONY_ERR_UNINIT);
269     ASSERT_EQ(client->CloseUnFinishedUssd(SIM1_SLOTID), TELEPHONY_ERR_UNINIT);
270     ASSERT_EQ(client->ObserverOnCallDetailsChange(), TELEPHONY_ERR_UNINIT);
271     ASSERT_EQ(client->InputDialerSpecialCode(PHONE_NUMBER), TELEPHONY_ERR_UNINIT);
272     ASSERT_EQ(client->RemoveMissedIncomingCallNotification(), TELEPHONY_ERR_UNINIT);
273     ASSERT_EQ(client->SetVoIPCallState(value), TELEPHONY_ERR_UNINIT);
274     ASSERT_EQ(client->GetVoIPCallState(value), TELEPHONY_ERR_UNINIT);
275     ASSERT_EQ(client->ReportAudioDeviceInfo(), TELEPHONY_ERR_UNINIT);
276     ASSERT_EQ(client->RequestCameraCapabilities(g_newCallId), TELEPHONY_ERR_UNINIT);
277 }
278 
279 /**
280  * @tc.number   Telephony_BluetoothCallClient_001
281  * @tc.name     test error branch
282  * @tc.desc     Function test
283  */
284 HWTEST_F(ClientErrorBranchTest, Telephony_BluetoothCallClient_001, Function | MediumTest | Level3)
285 {
286     std::shared_ptr<BluetoothCallClient> bluetoothCallClient = std::make_shared<BluetoothCallClient>();
287     bluetoothCallClient->UnInit();
288     ASSERT_NE(bluetoothCallClient->RegisterCallBack(nullptr), TELEPHONY_SUCCESS);
289     ASSERT_NE(bluetoothCallClient->UnRegisterCallBack(), TELEPHONY_SUCCESS);
290     std::u16string value = u"";
291     AppExecFwk::PacMap extras;
292     bool enabled;
293     bluetoothCallClient->IsNewCallAllowed(enabled);
294     bluetoothCallClient->IsInEmergencyCall(enabled);
295     bluetoothCallClient->SetMuted(false);
296     bluetoothCallClient->MuteRinger();
297     bluetoothCallClient->SetAudioDevice(AudioDeviceType::DEVICE_BLUETOOTH_SCO, "test");
298     bluetoothCallClient->GetCurrentCallList(-1).size();
299     ASSERT_NE(bluetoothCallClient->DialCall(value, extras), TELEPHONY_SUCCESS);
300     ASSERT_NE(bluetoothCallClient->AnswerCall(), TELEPHONY_SUCCESS);
301     ASSERT_NE(bluetoothCallClient->RejectCall(), TELEPHONY_SUCCESS);
302     ASSERT_NE(bluetoothCallClient->HangUpCall(), TELEPHONY_SUCCESS);
303     ASSERT_GE(bluetoothCallClient->GetCallState(), TELEPHONY_SUCCESS);
304     ASSERT_NE(bluetoothCallClient->HoldCall(), TELEPHONY_SUCCESS);
305     ASSERT_NE(bluetoothCallClient->UnHoldCall(), TELEPHONY_SUCCESS);
306     ASSERT_NE(bluetoothCallClient->SwitchCall(), TELEPHONY_SUCCESS);
307     ASSERT_NE(bluetoothCallClient->CombineConference(), TELEPHONY_SUCCESS);
308     ASSERT_NE(bluetoothCallClient->SeparateConference(), TELEPHONY_SUCCESS);
309     ASSERT_NE(bluetoothCallClient->KickOutFromConference(), TELEPHONY_SUCCESS);
310     ASSERT_NE(bluetoothCallClient->StartDtmf('a'), TELEPHONY_SUCCESS);
311     ASSERT_NE(bluetoothCallClient->StopDtmf(), TELEPHONY_SUCCESS);
312     ASSERT_NE(bluetoothCallClient->IsRinging(enabled), TELEPHONY_SUCCESS);
313 }
314 
315 /********************************************* Test DialCall()***********************************************/
316 /**
317  * @tc.number   Telephony_CallManager_DialCall_0100
318  * @tc.name     make a normal phone call with card1, TYPE_VOICE
319  * @tc.desc     Function test
320  * @tc.require: I5P2WO
321  */
322 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0100, Function | MediumTest | Level1)
323 {
324     AccessToken token;
325     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
326         return;
327     }
328     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
329         return;
330     }
331     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
332     std::string phoneNumber = "11111111111";
333     if (HasSimCard(SIM1_SLOTID)) {
334         InitDialInfo(
335             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
336         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
337         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
338         sleep(WAIT_TIME);
339         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
340             HangUpCall();
341         }
342     }
343 
344     if (HasSimCard(SIM2_SLOTID)) {
345         InitDialInfo(
346             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
347         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
348         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
349         sleep(WAIT_TIME);
350         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
351             HangUpCall();
352         }
353     }
354 }
355 
356 /**
357  * @tc.number   Telephony_CallManager_DialCall_0200
358  * @tc.name     make a normal phone call with null telephone numbers,
359  *              wait for the correct status of the callback to execute correctly
360  * @tc.desc     Function test
361  * @tc.require: I5P2WO
362  */
363 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0200, Function | MediumTest | Level1)
364 {
365     AccessToken token;
366     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
367         return;
368     }
369     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
370         return;
371     }
372     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
373     if (HasSimCard(SIM1_SLOTID)) {
374         InitDialInfo(
375             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
376         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(""), dialInfo_);
377         EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
378     }
379     if (HasSimCard(SIM2_SLOTID)) {
380         InitDialInfo(
381             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
382         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(""), dialInfo_);
383         EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
384     }
385 }
386 
387 /**
388  * @tc.number   Telephony_CallManager_DialCall_0300
389  * @tc.name     make a normal phone call with telephone numbers is negative number
390  * @tc.desc     Function test
391  * @tc.require: I5P2WO
392  */
393 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0300, Function | MediumTest | Level2)
394 {
395     AccessToken token;
396     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
397         return;
398     }
399     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
400         return;
401     }
402     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
403     std::string phoneNumber = "-12354785268";
404     if (HasSimCard(SIM1_SLOTID)) {
405         InitDialInfo(
406             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
407         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
408         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
409         sleep(WAIT_TIME);
410         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
411             HangUpCall();
412         }
413     }
414     if (HasSimCard(SIM2_SLOTID)) {
415         InitDialInfo(
416             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
417         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
418         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
419         sleep(WAIT_TIME);
420         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
421             HangUpCall();
422         }
423     }
424 }
425 
426 /**
427  * @tc.number   Telephony_CallManager_DialCall_0400
428  * @tc.name     make a normal phone call with telephone numbers is too long
429  * @tc.desc     Function test
430  * @tc.require: I5P2WO
431  */
432 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0400, Function | MediumTest | Level2)
433 {
434     AccessToken token;
435     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
436         return;
437     }
438     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
439         return;
440     }
441     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
442     std::string phoneNumber = "19119080646435437102938190283912471651865810514786470168818468143768714648";
443     if (HasSimCard(SIM1_SLOTID)) {
444         InitDialInfo(
445             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
446         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
447         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
448         sleep(WAIT_TIME);
449         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
450             HangUpCall();
451         }
452     }
453 
454     if (HasSimCard(SIM2_SLOTID)) {
455         InitDialInfo(
456             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
457         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
458         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
459         sleep(WAIT_TIME);
460         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
461             HangUpCall();
462         }
463     }
464 }
465 
466 /**
467  * @tc.number   Telephony_CallManager_DialCall_0500
468  * @tc.name     If an invalid number is dialed, the DialCall() interface succeeds, but callId is not generated
469  * @tc.desc     Function test
470  * @tc.require: I5P2WO
471  */
472 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0500, Function | MediumTest | Level3)
473 {
474     AccessToken token;
475     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
476         return;
477     }
478     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
479         return;
480     }
481     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
482     if (HasSimCard(SIM1_SLOTID)) {
483         InitDialInfo(
484             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
485         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("19!@#$%^&*:"), dialInfo_);
486         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
487         sleep(WAIT_TIME);
488         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
489             HangUpCall();
490         }
491     }
492     if (HasSimCard(SIM2_SLOTID)) {
493         InitDialInfo(
494             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
495         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("19!@#$%^&*:"), dialInfo_);
496         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
497         sleep(WAIT_TIME);
498         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
499             HangUpCall();
500         }
501     }
502 }
503 
504 /**
505  * @tc.number   Telephony_CallManager_DialCall_1000 to do ...
506  * @tc.name     make a normal phone call with card1, TYPE_VOICE, import phonynumber 10086
507  * @tc.desc     Function test
508  */
509 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1000, Function | MediumTest | Level0)
510 {
511     AccessToken token;
512     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
513         return;
514     }
515     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
516         return;
517     }
518     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
519     if (HasSimCard(SIM1_SLOTID)) {
520         InitDialInfo(
521             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
522         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086"), dialInfo_);
523         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
524         sleep(WAIT_TIME);
525         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
526             HangUpCall();
527         }
528     }
529     if (HasSimCard(SIM2_SLOTID)) {
530         InitDialInfo(
531             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
532         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086"), dialInfo_);
533         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
534         sleep(WAIT_TIME);
535         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
536             HangUpCall();
537         }
538     }
539 }
540 
541 /**
542  * @tc.number   Telephony_CallManager_DialCall_1100
543  * @tc.name     make a normal phone call with card1, TYPE_VOICE, slot id was invalid
544  * @tc.desc     Function test
545  * @tc.require: I5P2WA
546  */
547 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1100, Function | MediumTest | Level0)
548 {
549     AccessToken token;
550     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
551         return;
552     }
553     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
554         return;
555     }
556     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
557     std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
558     InitDialInfo(INVALID_SLOT_ID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
559         (int32_t)DialType::DIAL_CARRIER_TYPE);
560     int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
561     EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
562 }
563 
564 /**
565  * @tc.number   Telephony_CallManager_DialCall_1200
566  * @tc.name     make a normal phone call with card1, TYPE_VOICE, slot id out of count
567  * @tc.desc     Function test
568  * @tc.require: I5P2WA
569  */
570 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1200, Function | MediumTest | Level0)
571 {
572     AccessToken token;
573     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
574         return;
575     }
576     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
577         return;
578     }
579     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
580     std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
581     int32_t slotId = SIM_SLOT_COUNT; // out of the count
582     InitDialInfo(slotId, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
583         (int32_t)DialType::DIAL_CARRIER_TYPE);
584     int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
585     EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
586 }
587 
588 /**
589  * @tc.number   Telephony_CallManager_DialCall_1300
590  * @tc.name     make a normal phone call with card1, TYPE_VOICE, video state was invalid
591  * @tc.desc     Function test
592  * @tc.require: I5P2WA
593  */
594 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1300, Function | MediumTest | Level0)
595 {
596     AccessToken token;
597     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
598         return;
599     }
600     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
601         return;
602     }
603     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
604     std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
605     if (HasSimCard(SIM1_SLOTID)) {
606         InitDialInfo(
607             SIM1_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
608         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
609         EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
610     }
611     if (HasSimCard(SIM2_SLOTID)) {
612         InitDialInfo(
613             SIM2_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
614         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
615         EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
616     }
617 }
618 
619 /**
620  * @tc.number   Telephony_CallManager_DialCall_1400
621  * @tc.name     make a normal phone call without permission
622  * @tc.desc     Function test
623  */
624 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1400, Function | MediumTest | Level1)
625 {
626     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
627         return;
628     }
629     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
630         return;
631     }
632     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
633     if (HasSimCard(SIM1_SLOTID)) {
634         InitDialInfo(
635             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
636         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("22222222222"), dialInfo_);
637         EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
638     }
639 
640     if (HasSimCard(SIM2_SLOTID)) {
641         InitDialInfo(
642             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
643         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("22222222222"), dialInfo_);
644         EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
645     }
646 }
647 
648 /**
649  * @tc.number   Telephony_CallManager_DialCall_1500
650  * @tc.name     make a normal phone call with error dial type
651  * @tc.desc     Function test
652  */
653 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1500, Function | MediumTest | Level1)
654 {
655     AccessToken token;
656     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
657         return;
658     }
659     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
660         return;
661     }
662     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
663     std::string phoneNumber = "33333333333";
664     if (HasSimCard(SIM1_SLOTID)) {
665         InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, INVALID_DIAL_TYPE);
666         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
667         EXPECT_EQ(ret, CALL_ERR_UNKNOW_DIAL_TYPE);
668     }
669 
670     if (HasSimCard(SIM2_SLOTID)) {
671         InitDialInfo(SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, INVALID_DIAL_TYPE);
672         int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
673         EXPECT_EQ(ret, CALL_ERR_UNKNOW_DIAL_TYPE);
674     }
675 }
676 
677 /**
678  * @tc.number   Telephony_CallManager_DialCall_1600
679  * @tc.name     make a normal phone call with card1, TYPE_VOICE, video state was invalid
680  * @tc.desc     Function test
681  */
682 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1600, Function | MediumTest | Level0)
683 {
684     AccessToken token;
685     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
686         return;
687     }
688     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
689         return;
690     }
691     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
692     std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
693     ASSERT_TRUE(blueToothClientPtr_ != nullptr);
694     if (HasSimCard(SIM1_SLOTID)) {
695         InitDialInfo(
696             SIM1_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
697         int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
698         EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
699     }
700     if (HasSimCard(SIM2_SLOTID)) {
701         InitDialInfo(
702             SIM2_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
703         int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
704         EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
705     }
706 }
707 
708 /**
709  * @tc.number   Telephony_CallManager_DialCall_1700
710  * @tc.name     make a normal phone call with telephone numbers is too long
711  * @tc.desc     Function test
712  */
713 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1700, Function | MediumTest | Level2)
714 {
715     AccessToken token;
716     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
717         return;
718     }
719     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
720         return;
721     }
722     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
723     ASSERT_TRUE(blueToothClientPtr_ != nullptr);
724     std::string phoneNumber =
725         "19119080646435437102938190283912471651865851478647016881846814376871464810514786470168818468143768714648";
726     if (HasSimCard(SIM1_SLOTID)) {
727         InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
728             (int32_t)DialType::DIAL_CARRIER_TYPE);
729         int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
730         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
731         sleep(WAIT_TIME);
732         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
733             HangUpCall();
734         }
735     }
736 
737     if (HasSimCard(SIM2_SLOTID)) {
738         InitDialInfo(SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
739             (int32_t)DialType::DIAL_CARRIER_TYPE);
740         int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
741         EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
742         sleep(WAIT_TIME);
743         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
744             HangUpCall();
745         }
746     }
747 }
748 
749 /**
750  * @tc.number   Telephony_CallManager_DialCall_1800
751  * @tc.name     make a normal phone call with null telephone numbers,
752  *              wait for the correct status of the callback to execute correctly
753  * @tc.desc     Function test
754  */
755 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1800, Function | MediumTest | Level1)
756 {
757     AccessToken token;
758     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
759         return;
760     }
761     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
762         return;
763     }
764     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
765     std::string phoneNumber = "";
766     ASSERT_TRUE(blueToothClientPtr_ != nullptr);
767     if (HasSimCard(SIM1_SLOTID)) {
768         InitDialInfo(
769             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
770         int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
771         EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
772     }
773     if (HasSimCard(SIM2_SLOTID)) {
774         InitDialInfo(
775             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
776         int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
777         EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
778     }
779 }
780 
781 /**
782  * @tc.number   Telephony_CallManager_DialCall_1900
783  * @tc.name     make a normal phone call with card1, TYPE_VOICE, slot id out of count
784  * @tc.desc     Function test
785  */
786 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1900, Function | MediumTest | Level0)
787 {
788     AccessToken token;
789     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
790         return;
791     }
792     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
793         return;
794     }
795     ASSERT_TRUE(blueToothClientPtr_ != nullptr);
796     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
797     std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
798     int32_t slotId = SIM_SLOT_COUNT; // out of the count
799     InitDialInfo(slotId, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
800         (int32_t)DialType::DIAL_CARRIER_TYPE);
801     int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
802     EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
803 }
804 
805 /**
806  * @tc.number   Telephony_CallManager_DialCall_2000
807  * @tc.name     make a normal phone call with card1, TYPE_VOICE
808  * @tc.desc     Function test
809  * @tc.require: I5P2WO
810  */
811 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_2000, Function | MediumTest | Level1)
812 {
813     AccessToken token;
814     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
815         return;
816     }
817     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
818         return;
819     }
820     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
821     if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
822         HangUpCall();
823     }
824     std::string phoneNumber = "10086";
825     CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
826     if (HasSimCard(SIM1_SLOTID)) {
827         InitDialInfo(
828             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
829         EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
830         sleep(WAIT_TIME);
831         if (CallInfoManager::HasActiveStatus()) {
832             EXPECT_EQ(CallManagerGtest::clientPtr_->HoldCall(g_newCallId), RETURN_VALUE_IS_ZERO);
833             sleep(WAIT_TIME);
834             EXPECT_EQ(CallManagerGtest::clientPtr_->UnHoldCall(g_newCallId), RETURN_VALUE_IS_ZERO);
835         }
836         sleep(WAIT_TIME);
837         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
838             HangUpCall();
839         }
840     }
841 
842     if (HasSimCard(SIM2_SLOTID)) {
843         InitDialInfo(
844             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
845         EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
846         if (CallInfoManager::HasActiveStatus()) {
847             EXPECT_EQ(CallManagerGtest::clientPtr_->HoldCall(g_newCallId), RETURN_VALUE_IS_ZERO);
848             sleep(WAIT_TIME);
849             EXPECT_EQ(CallManagerGtest::clientPtr_->UnHoldCall(g_newCallId), RETURN_VALUE_IS_ZERO);
850         }
851         sleep(WAIT_TIME);
852         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
853             HangUpCall();
854         }
855     }
856 }
857 
858 /**
859  * @tc.number   Telephony_CallManager_DialCall_2100
860  * @tc.name     make post dial call with pause
861  * @tc.desc     Function test
862  * @tc.require: I5P2WO
863  */
864 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_2100, Function | MediumTest | Level1)
865 {
866     AccessToken token;
867     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
868         return;
869     }
870     if (!CanDialCall(SIM1_SLOTID, SIM2_SLOTID)) {
871         return;
872     }
873     EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
874     if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
875         HangUpCall();
876     }
877     std::string phoneNumber = "10086,123";
878     if (HasSimCard(SIM1_SLOTID)) {
879         CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
880         InitDialInfo(
881             SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
882         EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
883         sleep(1);
884         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
885             HangUpCall();
886         }
887     }
888 
889     if (HasSimCard(SIM2_SLOTID)) {
890         CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
891         InitDialInfo(
892             SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
893         EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
894         sleep(1);
895         if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
896             HangUpCall();
897         }
898     }
899 }
900 
901 /********************************************* Test AnswerCall() ***********************************************/
902 /**
903  * @tc.number   Telephony_CallManager_AnswerCall_0100
904  * @tc.name     test AnswerCall with the callId does not exist
905  * @tc.desc     Function test
906  * @tc.require: I5P2WA
907  */
908 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0100, Function | MediumTest | Level1)
909 {
910     AccessToken token;
911     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
912         return;
913     }
914     if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
915         HangUpCall();
916     }
917     CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
918     int32_t callId = INVALID_NEGATIVE_ID;
919     int32_t videoState = (int32_t)VideoStateType::TYPE_VOICE;
920     EXPECT_NE(CallManagerGtest::clientPtr_->AnswerCall(callId, videoState), RETURN_VALUE_IS_ZERO);
921 }
922 
923 /**
924  * @tc.number   Telephony_CallManager_AnswerCall_0200
925  * @tc.name     test AnswerCall with the videoState does not exist
926  * @tc.desc     Function test
927  * @tc.require: I5P2WA
928  */
929 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0200, Function | MediumTest | Level2)
930 {
931     AccessToken token;
932     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
933         return;
934     }
935     CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
936     int32_t callId = INVALID_POSITIVE_ID;
937     int32_t videoState = INVALID_NEGATIVE_ID;
938     EXPECT_NE(CallManagerGtest::clientPtr_->AnswerCall(callId, videoState), RETURN_VALUE_IS_ZERO);
939 }
940 
941 /**
942  * @tc.number   Telephony_CallManager_AnswerCall_0300
943  * @tc.name     test AnswerCall without permission
944  * @tc.desc     Function test
945  */
946 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0300, Function | MediumTest | Level2)
947 {
948     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
949         return;
950     }
951     CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
952     int32_t callId = INVALID_POSITIVE_ID;
953     int32_t videoState = INVALID_NEGATIVE_ID;
954     EXPECT_NE(CallManagerGtest::clientPtr_->AnswerCall(callId, videoState), RETURN_VALUE_IS_ZERO);
955 }
956 
957 /**
958  * @tc.number   Telephony_CallManager_AnswerCall_0400
959  * @tc.name     test AnswerCall with the callId does not exist
960  * @tc.desc     Function test
961  */
962 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0400, Function | MediumTest | Level2)
963 {
964     AccessToken token;
965     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
966         return;
967     }
968     CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
969     ASSERT_TRUE(blueToothClientPtr_ != nullptr);
970     EXPECT_NE(CallManagerGtest::blueToothClientPtr_->AnswerCall(), RETURN_VALUE_IS_ZERO);
971 }
972 } // namespace Telephony
973 } // namespace OHOS
974