1 /*
2 * Copyright (C) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define private public
17 #define protected public
18 #include "cellular_call_config.h"
19 #include "cellular_call_handler.h"
20 #include "cellular_call_proxy.h"
21 #include "cellular_call_register.h"
22 #include "cellular_call_service.h"
23 #include "tel_ril_call_parcel.h"
24 #include "ims_call_callback_proxy.h"
25 #include "ims_call_callback_stub.h"
26 #include "ims_call_client.h"
27 #include "ims_control.h"
28 #include "ims_error.h"
29 #include "securec.h"
30 #include "call_manager_errors.h"
31 #include "cellular_call_interface.h"
32 #include "core_service_client.h"
33 #include "gtest/gtest.h"
34 #include "ims_core_service_client.h"
35 #include "iservice_registry.h"
36 #include "system_ability_definition.h"
37 #include "token.h"
38
39 namespace OHOS {
40 namespace Telephony {
41 using namespace testing::ext;
42 const int32_t SIM1_SLOTID = 0;
43 const int32_t SIM2_SLOTID = 1;
44 const std::string PHONE_NUMBER = "0000000";
45 const std::string PHONE_NUMBER_SECOND = "1111111";
46 const std::string PHONE_NUMBER_THIRD = "2222222";
47 const std::string PHONE_NUMBER_FOUR = "3333333";
48
49 class Ims1Test : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp();
54 void TearDown();
55
HasSimCard(int32_t slotId)56 bool HasSimCard(int32_t slotId)
57 {
58 bool hasSimCard = false;
59 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
60 return hasSimCard;
61 }
CanUseImsService(int32_t slotId,ImsServiceType type)62 bool CanUseImsService(int32_t slotId, ImsServiceType type)
63 {
64 ImsRegInfo info;
65 CoreServiceClient::GetInstance().GetImsRegStatus(slotId, type, info);
66 bool imsReg = info.imsRegState == ImsRegState::IMS_REGISTERED;
67 return imsReg;
68 }
69
InitCellularCallInfo(int32_t accountId,std::string phonenumber,CellularCallInfo & callInfo)70 int32_t InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo)
71 {
72 callInfo.accountId = accountId;
73 callInfo.slotId = accountId;
74 callInfo.index = accountId;
75 callInfo.callType = CallType::TYPE_IMS;
76 callInfo.videoState = 0; // 0 means audio
77 if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
78 return TELEPHONY_ERR_MEMSET_FAIL;
79 }
80 if (phonenumber.length() > static_cast<size_t>(kMaxNumberLen)) {
81 return CALL_ERR_NUMBER_OUT_OF_RANGE;
82 }
83 if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, phonenumber.c_str(), phonenumber.length()) != EOK) {
84 return TELEPHONY_ERR_MEMCPY_FAIL;
85 }
86 return TELEPHONY_SUCCESS;
87 };
88
TestDialCallByIms(int32_t slotId,std::string code)89 int32_t TestDialCallByIms(int32_t slotId, std::string code)
90 {
91 AccessToken token;
92 auto saMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
93 if (saMgr == nullptr) {
94 return TELEPHONY_ERR_FAIL;
95 }
96 auto remote = saMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
97 if (remote == nullptr) {
98 return TELEPHONY_ERR_FAIL;
99 }
100 auto telephonyService = iface_cast<CellularCallInterface>(remote);
101 if (telephonyService == nullptr) {
102 return TELEPHONY_ERR_FAIL;
103 }
104 CellularCallInfo imsCellularCallInfo;
105 int32_t ret = TELEPHONY_SUCCESS;
106 ret = InitCellularCallInfo(slotId, code, imsCellularCallInfo);
107 if (ret != TELEPHONY_SUCCESS) {
108 return ret;
109 }
110 // open ims, make this time use ims to test
111 ret = telephonyService->SetImsSwitchStatus(slotId, true);
112 if (ret != TELEPHONY_SUCCESS) {
113 return ret;
114 }
115 ret = telephonyService->Dial(imsCellularCallInfo);
116 return ret;
117 };
118 };
119
SetUpTestCase(void)120 void Ims1Test::SetUpTestCase(void)
121 {
122 // step 3: Set Up Test Case
123 }
124
TearDownTestCase(void)125 void Ims1Test::TearDownTestCase(void)
126 {
127 // step 3: Tear Down Test Case
128 }
129
SetUp(void)130 void Ims1Test::SetUp(void) {}
131
TearDown(void)132 void Ims1Test::TearDown(void)
133 {
134 // step 3: input testcase teardown step
135 }
136 /**
137 * @tc.number cellular_call_ims_test_001
138 * @tc.name Test the corresponding functions by entering commands, such as 300 -- SetCallPreferenceMode, 301 --
139 * GetCallPreferenceMode, etc
140 * @tc.desc Function test
141 */
142 HWTEST_F(Ims1Test, cellular_call_ims_test_001, Function | MediumTest | Level0)
143 {
144 AccessToken token;
145 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
146 ASSERT_TRUE(systemAbilityMgr != nullptr);
147 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
148 ASSERT_TRUE(remote != nullptr);
149 auto telephonyService = iface_cast<CellularCallInterface>(remote);
150 ASSERT_TRUE(telephonyService != nullptr);
151 std::cout << "HWTEST_F cellular_call_ims_test_001";
152 }
153
154 /**
155 * @tc.number cellular_call_DialCall_0001
156 * @tc.name Test for SetClip function by ims
157 * @tc.desc Function test
158 */
159 HWTEST_F(Ims1Test, cellular_call_DialCall_0001, Function | MediumTest | Level2)
160 {
161 AccessToken token;
162 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
163 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*30#");
164 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
165 }
166 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
167 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*30#");
168 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
169 }
170 }
171
172 /**
173 * @tc.number cellular_call_DialCall_0002
174 * @tc.name Test for SetClip function by ims
175 * @tc.desc Function test
176 */
177 HWTEST_F(Ims1Test, cellular_call_DialCall_0002, Function | MediumTest | Level2)
178 {
179 AccessToken token;
180 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
181 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#30#");
182 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
183 }
184 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
185 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#30#");
186 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
187 }
188 }
189
190 /**
191 * @tc.number cellular_call_DialCall_0003
192 * @tc.name Test for getClip function by ims
193 * @tc.desc Function test
194 */
195 HWTEST_F(Ims1Test, cellular_call_DialCall_0003, Function | MediumTest | Level2)
196 {
197 AccessToken token;
198 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
199 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#30#");
200 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
201 }
202 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
203 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#30#");
204 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
205 }
206 }
207
208 /**
209 * @tc.number cellular_call_DialCall_0004
210 * @tc.name Test for SetClir function by ims
211 * @tc.desc Function test
212 */
213 HWTEST_F(Ims1Test, cellular_call_DialCall_0004, Function | MediumTest | Level2)
214 {
215 AccessToken token;
216 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
217 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*31#");
218 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
219 }
220 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
221 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*31#");
222 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
223 }
224 }
225
226 /**
227 * @tc.number cellular_call_DialCall_0005
228 * @tc.name Test for SetClir function by ims
229 * @tc.desc Function test
230 */
231 HWTEST_F(Ims1Test, cellular_call_DialCall_0005, Function | MediumTest | Level2)
232 {
233 AccessToken token;
234 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
235 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#31#");
236 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
237 }
238 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
239 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#31#");
240 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
241 }
242 }
243
244 /**
245 * @tc.number cellular_call_DialCall_0006
246 * @tc.name Test for GetClir function by ims
247 * @tc.desc Function test
248 */
249 HWTEST_F(Ims1Test, cellular_call_DialCall_0006, Function | MediumTest | Level2)
250 {
251 AccessToken token;
252 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
253 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#31#");
254 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
255 }
256 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
257 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#31#");
258 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
259 }
260 }
261
262 /**
263 * @tc.number cellular_call_DialCall_0007
264 * @tc.name Test for SetCallTransfer function by ims
265 * @tc.desc Function test
266 */
267 HWTEST_F(Ims1Test, cellular_call_DialCall_0007, Function | MediumTest | Level2)
268 {
269 AccessToken token;
270 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
271 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*21#");
272 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
273 }
274 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
275 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*21#");
276 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
277 }
278 }
279
280 /**
281 * @tc.number cellular_call_DialCall_0008
282 * @tc.name Test for SetCallTransfer function by ims
283 * @tc.desc Function test
284 */
285 HWTEST_F(Ims1Test, cellular_call_DialCall_0008, Function | MediumTest | Level2)
286 {
287 AccessToken token;
288 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
289 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#21#");
290 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
291 }
292 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
293 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#21#");
294 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
295 }
296 }
297
298 /**
299 * @tc.number cellular_call_DialCall_0009
300 * @tc.name Test for GetCallTransfer function by ims
301 * @tc.desc Function test
302 */
303 HWTEST_F(Ims1Test, cellular_call_DialCall_0009, Function | MediumTest | Level2)
304 {
305 AccessToken token;
306 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
307 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#21#");
308 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
309 }
310 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
311 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#21#");
312 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
313 }
314 }
315
316 /**
317 * @tc.number cellular_call_DialCall_0010
318 * @tc.name Test for SetCallRestriction function by ims
319 * @tc.desc Function test
320 */
321 HWTEST_F(Ims1Test, cellular_call_DialCall_0010, Function | MediumTest | Level2)
322 {
323 AccessToken token;
324 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
325 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*33#");
326 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
327 }
328 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
329 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*33#");
330 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
331 }
332 }
333
334 /**
335 * @tc.number cellular_call_DialCall_0011
336 * @tc.name Test for SetCallRestriction function by ims
337 * @tc.desc Function test
338 */
339 HWTEST_F(Ims1Test, cellular_call_DialCall_0011, Function | MediumTest | Level2)
340 {
341 AccessToken token;
342 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
343 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#33#");
344 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
345 }
346 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
347 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#33#");
348 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
349 }
350 }
351
352 /**
353 * @tc.number cellular_call_DialCall_0012
354 * @tc.name Test for GetCallRestriction function by ims
355 * @tc.desc Function test
356 */
357 HWTEST_F(Ims1Test, cellular_call_DialCall_0012, Function | MediumTest | Level2)
358 {
359 AccessToken token;
360 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
361 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#33#");
362 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
363 }
364 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
365 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#33#");
366 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
367 }
368 }
369
370 /**
371 * @tc.number cellular_call_DialCall_0013
372 * @tc.name Test for SetCallWaiting function by ims
373 * @tc.desc Function test
374 */
375 HWTEST_F(Ims1Test, cellular_call_DialCall_0013, Function | MediumTest | Level2)
376 {
377 AccessToken token;
378 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
379 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*43#");
380 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
381 }
382 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
383 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*43#");
384 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
385 }
386 }
387
388 /**
389 * @tc.number cellular_call_DialCall_0014
390 * @tc.name Test for SetCallWaiting function by ims
391 * @tc.desc Function test
392 */
393 HWTEST_F(Ims1Test, cellular_call_DialCall_0014, Function | MediumTest | Level2)
394 {
395 AccessToken token;
396 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
397 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#43#");
398 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
399 }
400 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
401 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#43#");
402 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
403 }
404 }
405
406 /**
407 * @tc.number cellular_call_DialCall_0015
408 * @tc.name Test for GetCallWaiting function by ims
409 * @tc.desc Function test
410 */
411 HWTEST_F(Ims1Test, cellular_call_DialCall_0015, Function | MediumTest | Level2)
412 {
413 AccessToken token;
414 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
415 int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#43#");
416 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
417 ret = TestDialCallByIms(SIM1_SLOTID, "*#4@3#");
418 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
419 }
420 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
421 int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#43#");
422 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
423 ret = TestDialCallByIms(SIM2_SLOTID, "*#4@3#");
424 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
425 }
426 }
427
428 /**
429 * @tc.number cellular_call_HangUpCall_0001
430 * @tc.name Test for HangUp function by ims
431 * @tc.desc Function test
432 */
433 HWTEST_F(Ims1Test, cellular_call_HangUpCall_0001, Function | MediumTest | Level2)
434 {
435 AccessToken token;
436 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
437 ASSERT_TRUE(systemAbilityMgr != nullptr);
438 auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
439 ASSERT_TRUE(hangUpCallRemote != nullptr);
440 auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
441 ASSERT_TRUE(telephonyService != nullptr);
442 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
443 CellularCallInfo callInfo;
444 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
445 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
446 ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
447 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
448 ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
449 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
450 }
451 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
452 CellularCallInfo callInfo;
453 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
454 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
455 ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
456 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
457 ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
458 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
459 }
460 }
461
462 /**
463 * @tc.number cellular_call_AnswerCall_0001
464 * @tc.name Test for answer function by ims
465 * @tc.desc Function test
466 */
467 HWTEST_F(Ims1Test, cellular_call_AnswerCall_0001, Function | MediumTest | Level2)
468 {
469 AccessToken token;
470 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
471 ASSERT_TRUE(systemAbilityMgr != nullptr);
472 auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
473 ASSERT_TRUE(answerCallRemote != nullptr);
474 auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
475 ASSERT_TRUE(telephonyService != nullptr);
476 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
477 CellularCallInfo callInfo;
478 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
479 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
480 ret = telephonyService->Answer(callInfo);
481 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
482 }
483 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
484 CellularCallInfo callInfo;
485 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
486 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
487 ret = telephonyService->Answer(callInfo);
488 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
489 }
490 }
491
492 /**
493 * @tc.number cellular_call_RejectCall_0001
494 * @tc.name Test for reject function by ims
495 * @tc.desc Function test
496 */
497 HWTEST_F(Ims1Test, cellular_call_RejectCall_0001, Function | MediumTest | Level2)
498 {
499 AccessToken token;
500 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
501 ASSERT_TRUE(systemAbilityMgr != nullptr);
502 auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
503 ASSERT_TRUE(rejectCallRemote != nullptr);
504 auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
505 ASSERT_TRUE(telephonyService != nullptr);
506 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
507 CellularCallInfo callInfo;
508 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
509 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
510 ret = telephonyService->Reject(callInfo);
511 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
512 }
513 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
514 CellularCallInfo callInfo;
515 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
516 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
517 ret = telephonyService->Reject(callInfo);
518 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
519 }
520 }
521
522 /**
523 * @tc.number cellular_call_HoldCall_0001
524 * @tc.name Test for hold call function by ims
525 * @tc.desc Function test
526 */
527 HWTEST_F(Ims1Test, cellular_call_HoldCall_0001, Function | MediumTest | Level2)
528 {
529 AccessToken token;
530 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
531 ASSERT_TRUE(systemAbilityMgr != nullptr);
532 auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
533 ASSERT_TRUE(holdCallRemote != nullptr);
534 auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
535 ASSERT_TRUE(telephonyService != nullptr);
536 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
537 CellularCallInfo callInfo;
538 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
539 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
540 ret = telephonyService->HoldCall(callInfo);
541 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
542 }
543 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
544 CellularCallInfo callInfo;
545 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
546 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
547 ret = telephonyService->HoldCall(callInfo);
548 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
549 }
550 }
551
552 /**
553 * @tc.number cellular_call_UnHoldCall_0001
554 * @tc.name Test for unhold call function by ims
555 * @tc.desc Function test
556 */
557 HWTEST_F(Ims1Test, cellular_call_UnHoldCall_0001, Function | MediumTest | Level2)
558 {
559 AccessToken token;
560 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
561 ASSERT_TRUE(systemAbilityMgr != nullptr);
562 auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
563 ASSERT_TRUE(unHoldCallRemote != nullptr);
564 auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
565 ASSERT_TRUE(telephonyService != nullptr);
566 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
567 CellularCallInfo callInfo;
568 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
569 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
570 ret = telephonyService->UnHoldCall(callInfo);
571 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
572 }
573 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
574 CellularCallInfo callInfo;
575 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
576 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
577 ret = telephonyService->UnHoldCall(callInfo);
578 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
579 }
580 }
581
582 /**
583 * @tc.number cellular_call_SwitchCall_0001
584 * @tc.name Test for switch call function by ims
585 * @tc.desc Function test
586 */
587 HWTEST_F(Ims1Test, cellular_call_SwitchCall_0001, Function | MediumTest | Level2)
588 {
589 AccessToken token;
590 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
591 ASSERT_TRUE(systemAbilityMgr != nullptr);
592 auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
593 ASSERT_TRUE(switchCallRemote != nullptr);
594 auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
595 ASSERT_TRUE(telephonyService != nullptr);
596 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
597 CellularCallInfo callInfo;
598 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
599 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
600 ret = telephonyService->SwitchCall(callInfo);
601 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
602 }
603 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
604 CellularCallInfo callInfo;
605 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
606 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
607 ret = telephonyService->SwitchCall(callInfo);
608 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
609 }
610 }
611
612 /**
613 * @tc.number cellular_call_CombineConference_0001
614 * @tc.name Test for combineConference function by ims
615 * @tc.desc Function test
616 */
617 HWTEST_F(Ims1Test, cellular_call_CombineConference_0001, Function | MediumTest | Level2)
618 {
619 AccessToken token;
620 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
621 ASSERT_TRUE(systemAbilityMgr != nullptr);
622 auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
623 ASSERT_TRUE(combineRemote != nullptr);
624 auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
625 ASSERT_TRUE(telephonyService != nullptr);
626 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
627 CellularCallInfo callInfo;
628 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
629 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
630 ret = telephonyService->CombineConference(callInfo);
631 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
632 }
633 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
634 CellularCallInfo callInfo;
635 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
636 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
637 ret = telephonyService->CombineConference(callInfo);
638 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
639 }
640 }
641
642 /**
643 * @tc.number cellular_call_SeparateConference_0001
644 * @tc.name Test for separateConference function by ims
645 * @tc.desc Function test
646 */
647 HWTEST_F(Ims1Test, cellular_call_SeparateConference_0001, Function | MediumTest | Level2)
648 {
649 AccessToken token;
650 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
651 ASSERT_TRUE(systemAbilityMgr != nullptr);
652 auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
653 ASSERT_TRUE(separateRemote != nullptr);
654 auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
655 ASSERT_TRUE(telephonyService != nullptr);
656 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
657 CellularCallInfo callInfo;
658 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
659 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
660 ret = telephonyService->SeparateConference(callInfo);
661 EXPECT_EQ(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
662 }
663 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
664 CellularCallInfo callInfo;
665 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
666 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
667 ret = telephonyService->SeparateConference(callInfo);
668 EXPECT_EQ(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
669 }
670 }
671
672 /**
673 * @tc.number cellular_call_KickOutFromConference_0001
674 * @tc.name Test for KickOutFromConference function by ims
675 * @tc.desc Function test
676 */
677 HWTEST_F(Ims1Test, cellular_call_KickOutFromConference_0001, Function | MediumTest | Level2)
678 {
679 AccessToken token;
680 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
681 ASSERT_TRUE(systemAbilityMgr != nullptr);
682 auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
683 ASSERT_TRUE(kickOutRemote != nullptr);
684 auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
685 ASSERT_TRUE(telephonyService != nullptr);
686 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
687 CellularCallInfo callInfo;
688 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
689 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
690 ret = telephonyService->KickOutFromConference(callInfo);
691 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
692 }
693 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
694 CellularCallInfo callInfo;
695 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
696 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
697 ret = telephonyService->KickOutFromConference(callInfo);
698 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
699 }
700 }
701
702 /**
703 * @tc.number cellular_call_StartDtmf_0001
704 * @tc.name Test for startDtmf function by ims
705 * @tc.desc Function test
706 */
707 HWTEST_F(Ims1Test, cellular_call_StartDtmf_0001, Function | MediumTest | Level2)
708 {
709 AccessToken token;
710 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
711 ASSERT_TRUE(systemAbilityMgr != nullptr);
712 auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
713 ASSERT_TRUE(startDtmfRemote != nullptr);
714 auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
715 ASSERT_TRUE(telephonyService != nullptr);
716 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
717 CellularCallInfo callInfo;
718 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
719 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
720 char code = '1';
721 ret = telephonyService->StartDtmf(code, callInfo);
722 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
723 }
724 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
725 CellularCallInfo callInfo;
726 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
727 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
728 char code = '1';
729 ret = telephonyService->StartDtmf(code, callInfo);
730 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
731 }
732 }
733
734 /**
735 * @tc.number cellular_call_StopDtmf_0001
736 * @tc.name Test for stopDtmf function by ims
737 * @tc.desc Function test
738 */
739 HWTEST_F(Ims1Test, cellular_call_StopDtmf_0001, Function | MediumTest | Level2)
740 {
741 AccessToken token;
742 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
743 ASSERT_TRUE(systemAbilityMgr != nullptr);
744 auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
745 ASSERT_TRUE(stopDtmfRemote != nullptr);
746 auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
747 ASSERT_TRUE(telephonyService != nullptr);
748 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
749 CellularCallInfo callInfo;
750 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
751 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
752 ret = telephonyService->StopDtmf(callInfo);
753 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
754 }
755 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
756 CellularCallInfo callInfo;
757 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
758 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
759 ret = telephonyService->StopDtmf(callInfo);
760 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
761 }
762 }
763
764 /**
765 * @tc.number cellular_call_SendDtmf_0001
766 * @tc.name Test for sendDtmf function by ims
767 * @tc.desc Function test
768 */
769 HWTEST_F(Ims1Test, cellular_call_SendDtmf_0001, Function | MediumTest | Level2)
770 {
771 AccessToken token;
772 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
773 ASSERT_TRUE(systemAbilityMgr != nullptr);
774 auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
775 ASSERT_TRUE(sendDtmfRemote != nullptr);
776 auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
777 ASSERT_TRUE(telephonyService != nullptr);
778 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
779 CellularCallInfo callInfo;
780 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
781 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
782 char code = '1';
783 ret = telephonyService->SendDtmf(code, callInfo);
784 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
785 }
786 if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
787 CellularCallInfo callInfo;
788 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
789 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
790 char code = '1';
791 ret = telephonyService->SendDtmf(code, callInfo);
792 EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
793 }
794 }
795
796 /**
797 * @tc.number cellular_call_CanSetCallTransferTime_0001
798 * @tc.name Test for CanSetCallTransferTime function by ims
799 * @tc.desc Function test
800 */
801 HWTEST_F(Ims1Test, cellular_call_CanSetCallTransferTime_0001, Function | MediumTest | Level2)
802 {
803 AccessToken token;
804 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
805 ASSERT_TRUE(systemAbilityMgr != nullptr);
806 auto transferRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
807 ASSERT_TRUE(transferRemote != nullptr);
808 auto telephonyService = iface_cast<CellularCallInterface>(transferRemote);
809 ASSERT_TRUE(telephonyService != nullptr);
810 if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
811 bool result;
812 int32_t ret = telephonyService->CanSetCallTransferTime(SIM1_SLOTID, result);
813 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
814 }
815 if (HasSimCard(SIM2_SLOTID)) {
816 bool result;
817 int32_t ret = telephonyService->CanSetCallTransferTime(SIM2_SLOTID, result);
818 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
819 }
820 }
821
822
823 /**
824 * @tc.number cellular_call_SetVoNRState_0001
825 * @tc.name Test for SetVoNRState function
826 * @tc.desc Function test
827 */
828 HWTEST_F(Ims1Test, cellular_call_SetVoNRState_0001, Function | MediumTest | Level2)
829 {
830 AccessToken token;
831 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
832 ASSERT_TRUE(systemAbilityMgr != nullptr);
833 auto setVoNRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
834 ASSERT_TRUE(setVoNRRemote != nullptr);
835 auto telephonyService = iface_cast<CellularCallInterface>(setVoNRRemote);
836 ASSERT_TRUE(telephonyService != nullptr);
837 if (HasSimCard(SIM1_SLOTID)) {
838 telephonyService->SetVoNRState(SIM1_SLOTID, 1);
839 }
840 if (HasSimCard(SIM2_SLOTID)) {
841 telephonyService->SetVoNRState(SIM2_SLOTID, 1);
842 }
843 }
844 } // namespace Telephony
845 } // namespace OHOS
846