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