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