1 /*
2 * Copyright (C) 2025 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 #include <thread>
17 #include "mock_i_core_service.h"
18 #include "core_service.h"
19 #include "telephony_errors.h"
20 #include "sim_state_type.h"
21 #include "raw_parcel_callback_stub.h"
22 #include "sim_manager.h"
23 #include "network_search_manager.h"
24 #include "tel_ril_manager.h"
25 #include "telephony_permission_test_helper.h"
26
27 namespace OHOS {
28 namespace Telephony {
29 using namespace testing;
30 using namespace testing::ext;
31 namespace {
32 constexpr int64_t DELAY_TIME_MS = 10;
33 constexpr int64_t WAIT_TIME_MS = 2 * DELAY_TIME_MS;
34 constexpr int64_t DEFAULT_WAIT_TIME_MS = 1000;
35 std::shared_ptr<CoreService> g_coreService;
36
37 MockSimManager *g_mockSimManager;
38 MockINetworkSearch *g_mockNetworkSearchManager;
39 MockTelRilManager *g_mockTelRilManager;
40
41 std::shared_ptr<AppExecFwk::EventHandler> g_defaultHandler;
42 bool g_runInCaller = true;
43
44 sptr<IRawParcelCallback> g_directCall = nullptr;
45
RunInCaller(const std::function<void ()> task)46 void RunInCaller(const std::function<void()> task)
47 {
48 task();
49 }
RunInHandler(const std::function<void ()> task,int64_t delayed)50 void RunInHandler(const std::function<void()> task, int64_t delayed)
51 {
52 g_defaultHandler->PostTask(task, "", delayed);
53 }
AsyncRun(const std::function<void ()> task)54 void AsyncRun(const std::function<void()> task)
55 {
56 if (g_runInCaller) {
57 RunInCaller(task);
58 return;
59 }
60 RunInHandler(task, DELAY_TIME_MS);
61 }
SetRunInCaller()62 void SetRunInCaller()
63 {
64 g_runInCaller = true;
65 }
SetDelayRunInHandler()66 void SetDelayRunInHandler()
67 {
68 g_runInCaller = false;
69 }
70
71 class MockCoreService : public CoreService {
72 private:
AsyncNetSearchExecute(const std::function<void ()> task)73 void AsyncNetSearchExecute(const std::function<void()> task) override
74 {
75 AsyncRun(task);
76 }
AsyncSimGeneralExecute(const std::function<void ()> task)77 void AsyncSimGeneralExecute(const std::function<void()> task) override
78 {
79 AsyncRun(task);
80 }
AsyncSimPinExecute(const std::function<void ()> task)81 void AsyncSimPinExecute(const std::function<void()> task) override
82 {
83 AsyncRun(task);
84 }
85 };
86
87 class DirectCallRawParcelCallback : public IRawParcelCallback {
88 public:
AsObject()89 sptr<IRemoteObject> AsObject() override
90 {
91 return nullptr;
92 }
Transfer(std::function<void (MessageParcel &)> func,MessageParcel & data)93 void Transfer(std::function<void(MessageParcel &)> func, MessageParcel &data)
94 {
95 func(data);
96 }
97 };
98
99 class CoreServiceTest : public testing::Test {
100 public:
SetUpTestCase()101 static void SetUpTestCase()
102 {
103 g_coreService = std::make_shared<MockCoreService>();
104 g_directCall = sptr<DirectCallRawParcelCallback>::MakeSptr();
105
106 auto runner = AppExecFwk::EventRunner::Create("dt_defaultHandler", AppExecFwk::ThreadMode::FFRT);
107 g_defaultHandler = std::make_shared<AppExecFwk::EventHandler>(runner);
108 }
TearDownTestCase()109 static void TearDownTestCase()
110 {
111 std::this_thread::sleep_for(std::chrono::milliseconds(DEFAULT_WAIT_TIME_MS));
112 }
SetUp()113 void SetUp()
114 {
115 auto simManager = std::make_shared<SimManager>(nullptr);
116 auto networkSearchManager = std::make_shared<NetworkSearchManager>(nullptr, nullptr);
117 auto telRilManager = std::make_shared<TelRilManager>();
118
119 g_mockSimManager = std::static_pointer_cast<MockSimManager>(simManager).get();
120 g_mockNetworkSearchManager = std::static_pointer_cast<MockINetworkSearch>(networkSearchManager).get();
121 g_mockTelRilManager = std::static_pointer_cast<MockTelRilManager>(telRilManager).get();
122
123 g_coreService->simManager_ = simManager;
124 g_coreService->networkSearchManager_ = networkSearchManager;
125 g_coreService->telRilManager_ = telRilManager;
126 }
TearDown()127 void TearDown()
128 {
129 g_coreService->simManager_ = nullptr;
130 g_coreService->networkSearchManager_ = nullptr;
131 g_coreService->telRilManager_ = nullptr;
132 }
133 };
134
135 /****************************************************** GetImei *****************************************************/
136 HWTEST_F(CoreServiceTest, GetImei001, Function | MediumTest | Level1)
137 {
138 TelephonyPermissionTestHelper helper(false);
139 int32_t ret = g_coreService->GetImei(0, nullptr);
140 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
141 }
142
143 HWTEST_F(CoreServiceTest, GetImei002, Function | MediumTest | Level1)
144 {
145 TelephonyPermissionTestHelper helper(true);
146 int32_t ret = g_coreService->GetImei(0, nullptr);
147 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
148 }
149
150 HWTEST_F(CoreServiceTest, GetImei003, Function | MediumTest | Level1)
151 {
152 TelephonyPermissionTestHelper helper(true);
153 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
154 g_coreService->networkSearchManager_ = nullptr;
155 int32_t ret = g_coreService->GetImei(0, nullptr);
156 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
157 }
158
159 HWTEST_F(CoreServiceTest, GetImei004, Function | MediumTest | Level1)
160 {
161 TelephonyPermissionTestHelper helper(true);
162 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
163 int32_t ret = g_coreService->GetImei(0, nullptr);
164 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
165 }
166
167 HWTEST_F(CoreServiceTest, GetImei005, Function | MediumTest | Level1)
168 {
169 TelephonyPermissionTestHelper helper(true);
170 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
171 SetDelayRunInHandler();
172 int32_t ret = g_coreService->GetImei(0, g_directCall);
173 g_coreService->networkSearchManager_ = nullptr;
174 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
175 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
176 }
177
178 HWTEST_F(CoreServiceTest, GetImei006, Function | MediumTest | Level1)
179 {
180 TelephonyPermissionTestHelper helper(true);
181 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
182 SetRunInCaller();
183 EXPECT_CALL(*g_mockNetworkSearchManager, GetImei(_, _))
184 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
185 int32_t ret = g_coreService->GetImei(0, g_directCall);
186 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
187 }
188
189 /**************************************************** GetImeiSv *****************************************************/
190 HWTEST_F(CoreServiceTest, GetImeiSv001, Function | MediumTest | Level1)
191 {
192 TelephonyPermissionTestHelper helper(false);
193 int32_t ret = g_coreService->GetImeiSv(0, nullptr);
194 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
195 }
196
197 HWTEST_F(CoreServiceTest, GetImeiSv002, Function | MediumTest | Level1)
198 {
199 TelephonyPermissionTestHelper helper(true);
200 int32_t ret = g_coreService->GetImeiSv(0, nullptr);
201 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
202 }
203
204 HWTEST_F(CoreServiceTest, GetImeiSv003, Function | MediumTest | Level1)
205 {
206 TelephonyPermissionTestHelper helper(true);
207 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
208 g_coreService->networkSearchManager_ = nullptr;
209 int32_t ret = g_coreService->GetImeiSv(0, nullptr);
210 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
211 }
212
213 HWTEST_F(CoreServiceTest, GetImeiSv004, Function | MediumTest | Level1)
214 {
215 TelephonyPermissionTestHelper helper(true);
216 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
217 int32_t ret = g_coreService->GetImeiSv(0, nullptr);
218 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
219 }
220
221 HWTEST_F(CoreServiceTest, GetImeiSv005, Function | MediumTest | Level1)
222 {
223 TelephonyPermissionTestHelper helper(true);
224 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
225 SetDelayRunInHandler();
226 int32_t ret = g_coreService->GetImeiSv(0, g_directCall);
227 g_coreService->networkSearchManager_ = nullptr;
228 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
229 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
230 }
231
232 HWTEST_F(CoreServiceTest, GetImeiSv006, Function | MediumTest | Level1)
233 {
234 TelephonyPermissionTestHelper helper(true);
235 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
236 SetRunInCaller();
237 EXPECT_CALL(*g_mockNetworkSearchManager, GetImeiSv(_, _))
238 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
239 int32_t ret = g_coreService->GetImeiSv(0, g_directCall);
240 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
241 }
242
243 /**************************************************** IsCTSimCard ***************************************************/
244 HWTEST_F(CoreServiceTest, IsCTSimCard001, Function | MediumTest | Level1)
245 {
246 TelephonyPermissionTestHelper helper(false);
247 int32_t ret = g_coreService->IsCTSimCard(0, nullptr);
248 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
249 }
250
251 HWTEST_F(CoreServiceTest, IsCTSimCard002, Function | MediumTest | Level1)
252 {
253 TelephonyPermissionTestHelper helper(true);
254 int32_t ret = g_coreService->IsCTSimCard(0, nullptr);
255 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
256 }
257
258 HWTEST_F(CoreServiceTest, IsCTSimCard003, Function | MediumTest | Level1)
259 {
260 TelephonyPermissionTestHelper helper(true);
261 g_coreService->simManager_ = nullptr;
262 int32_t ret = g_coreService->IsCTSimCard(0, nullptr);
263 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
264 }
265
266 HWTEST_F(CoreServiceTest, IsCTSimCard004, Function | MediumTest | Level1)
267 {
268 TelephonyPermissionTestHelper helper(true);
269 SetDelayRunInHandler();
270 int32_t ret = g_coreService->IsCTSimCard(0, g_directCall);
271 g_coreService->simManager_ = nullptr;
272 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
273 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
274 }
275
276 HWTEST_F(CoreServiceTest, IsCTSimCard005, Function | MediumTest | Level1)
277 {
278 TelephonyPermissionTestHelper helper(true);
279 SetRunInCaller();
280 EXPECT_CALL(*g_mockSimManager, IsCTSimCard(_, _))
281 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
282 int32_t ret = g_coreService->IsCTSimCard(0, g_directCall);
283 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
284 }
285
286 /**************************************************** IsSimActive ***************************************************/
287 HWTEST_F(CoreServiceTest, IsSimActive001, Function | MediumTest | Level1)
288 {
289 g_coreService->simManager_ = nullptr;
290 bool ret = g_coreService->IsSimActive(0, nullptr);
291 EXPECT_FALSE(ret);
292 }
293
294 HWTEST_F(CoreServiceTest, IsSimActive002, Function | MediumTest | Level1)
295 {
296 bool ret = g_coreService->IsSimActive(0, nullptr);
297 EXPECT_FALSE(ret);
298 }
299
300 HWTEST_F(CoreServiceTest, IsSimActive003, Function | MediumTest | Level1)
301 {
302 SetDelayRunInHandler();
303 bool ret = g_coreService->IsSimActive(0, g_directCall);
304 g_coreService->simManager_ = nullptr;
305 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
306 EXPECT_TRUE(ret);
307 }
308
309 HWTEST_F(CoreServiceTest, IsSimActive004, Function | MediumTest | Level1)
310 {
311 SetRunInCaller();
312 EXPECT_CALL(*g_mockSimManager, IsSimActive(_))
313 .WillOnce(Return(true));
314 bool ret = g_coreService->IsSimActive(0, g_directCall);
315 EXPECT_TRUE(ret);
316 }
317
318 HWTEST_F(CoreServiceTest, IsSimActive005, Function | MediumTest | Level1)
319 {
320 SetRunInCaller();
321 EXPECT_CALL(*g_mockSimManager, IsSimActive(_))
322 .WillOnce(Return(false));
323 bool ret = g_coreService->IsSimActive(0, g_directCall);
324 EXPECT_TRUE(ret);
325 }
326
327 /************************************************* GetDefaultVoiceSimId *********************************************/
328 HWTEST_F(CoreServiceTest, GetDefaultVoiceSimId001, Function | MediumTest | Level1)
329 {
330 g_coreService->simManager_ = nullptr;
331 int32_t ret = g_coreService->GetDefaultVoiceSimId(nullptr);
332 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
333 }
334
335 HWTEST_F(CoreServiceTest, GetDefaultVoiceSimId002, Function | MediumTest | Level1)
336 {
337 int32_t ret = g_coreService->GetDefaultVoiceSimId(nullptr);
338 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
339 }
340
341 HWTEST_F(CoreServiceTest, GetDefaultVoiceSimId003, Function | MediumTest | Level1)
342 {
343 SetDelayRunInHandler();
344 int32_t ret = g_coreService->GetDefaultVoiceSimId(g_directCall);
345 g_coreService->simManager_ = nullptr;
346 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
347 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
348 }
349
350 HWTEST_F(CoreServiceTest, GetDefaultVoiceSimId004, Function | MediumTest | Level1)
351 {
352 SetRunInCaller();
353 EXPECT_CALL(*g_mockSimManager, GetDefaultVoiceSimId(_))
354 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
355 int32_t ret = g_coreService->GetDefaultVoiceSimId(g_directCall);
356 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
357 }
358
359 /*************************************************** GetShowNumber **************************************************/
360 HWTEST_F(CoreServiceTest, GetShowNumber001, Function | MediumTest | Level1)
361 {
362 TelephonyPermissionTestHelper helper(false);
363 int32_t ret = g_coreService->GetShowNumber(0, nullptr);
364 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
365 }
366
367 HWTEST_F(CoreServiceTest, GetShowNumber002, Function | MediumTest | Level1)
368 {
369 TelephonyPermissionTestHelper helper(true);
370 int32_t ret = g_coreService->GetShowNumber(0, nullptr);
371 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
372 }
373
374 HWTEST_F(CoreServiceTest, GetShowNumber003, Function | MediumTest | Level1)
375 {
376 TelephonyPermissionTestHelper helper(true);
377 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
378 g_coreService->simManager_ = nullptr;
379 int32_t ret = g_coreService->GetShowNumber(0, nullptr);
380 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
381 }
382
383 HWTEST_F(CoreServiceTest, GetShowNumber004, Function | MediumTest | Level1)
384 {
385 TelephonyPermissionTestHelper helper(true);
386 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
387 int32_t ret = g_coreService->GetShowNumber(0, nullptr);
388 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
389 }
390
391 HWTEST_F(CoreServiceTest, GetShowNumber005, Function | MediumTest | Level1)
392 {
393 TelephonyPermissionTestHelper helper(true);
394 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
395 SetDelayRunInHandler();
396 int32_t ret = g_coreService->GetShowNumber(0, g_directCall);
397 g_coreService->simManager_ = nullptr;
398 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
399 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
400 }
401
402 HWTEST_F(CoreServiceTest, GetShowNumber006, Function | MediumTest | Level1)
403 {
404 TelephonyPermissionTestHelper helper(true);
405 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
406 SetRunInCaller();
407 EXPECT_CALL(*g_mockSimManager, GetShowNumber(_, _))
408 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
409 int32_t ret = g_coreService->GetShowNumber(0, g_directCall);
410 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
411 }
412
413 /*************************************************** SetShowNumber **************************************************/
414 HWTEST_F(CoreServiceTest, SetShowNumber001, Function | MediumTest | Level1)
415 {
416 TelephonyPermissionTestHelper helper(false);
417 int32_t ret = g_coreService->SetShowNumber(0, u"", nullptr);
418 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
419 }
420
421 HWTEST_F(CoreServiceTest, SetShowNumber002, Function | MediumTest | Level1)
422 {
423 TelephonyPermissionTestHelper helper(true);
424 int32_t ret = g_coreService->SetShowNumber(0, u"", nullptr);
425 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
426 }
427
428 HWTEST_F(CoreServiceTest, SetShowNumber003, Function | MediumTest | Level1)
429 {
430 TelephonyPermissionTestHelper helper(true);
431 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
432 g_coreService->simManager_ = nullptr;
433 int32_t ret = g_coreService->SetShowNumber(0, u"", nullptr);
434 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
435 }
436
437 HWTEST_F(CoreServiceTest, SetShowNumber004, Function | MediumTest | Level1)
438 {
439 TelephonyPermissionTestHelper helper(true);
440 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
441 int32_t ret = g_coreService->SetShowNumber(0, u"", nullptr);
442 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
443 }
444
445 HWTEST_F(CoreServiceTest, SetShowNumber005, Function | MediumTest | Level1)
446 {
447 TelephonyPermissionTestHelper helper(true);
448 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
449 SetDelayRunInHandler();
450 int32_t ret = g_coreService->SetShowNumber(0, u"", g_directCall);
451 g_coreService->simManager_ = nullptr;
452 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
453 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
454 }
455
456 HWTEST_F(CoreServiceTest, SetShowNumber006, Function | MediumTest | Level1)
457 {
458 TelephonyPermissionTestHelper helper(true);
459 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
460 SetRunInCaller();
461 EXPECT_CALL(*g_mockSimManager, SetShowNumber(_, _))
462 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
463 int32_t ret = g_coreService->SetShowNumber(0, u"", g_directCall);
464 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
465 }
466
467 /**************************************************** SetShowName ***************************************************/
468 HWTEST_F(CoreServiceTest, SetShowName001, Function | MediumTest | Level1)
469 {
470 TelephonyPermissionTestHelper helper(false);
471 int32_t ret = g_coreService->SetShowName(0, u"", nullptr);
472 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
473 }
474
475 HWTEST_F(CoreServiceTest, SetShowName002, Function | MediumTest | Level1)
476 {
477 TelephonyPermissionTestHelper helper(true);
478 int32_t ret = g_coreService->SetShowName(0, u"", nullptr);
479 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
480 }
481
482 HWTEST_F(CoreServiceTest, SetShowName003, Function | MediumTest | Level1)
483 {
484 TelephonyPermissionTestHelper helper(true);
485 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
486 g_coreService->simManager_ = nullptr;
487 int32_t ret = g_coreService->SetShowName(0, u"", nullptr);
488 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
489 }
490
491 HWTEST_F(CoreServiceTest, SetShowName004, Function | MediumTest | Level1)
492 {
493 TelephonyPermissionTestHelper helper(true);
494 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
495 int32_t ret = g_coreService->SetShowName(0, u"", nullptr);
496 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
497 }
498
499 HWTEST_F(CoreServiceTest, SetShowName005, Function | MediumTest | Level1)
500 {
501 TelephonyPermissionTestHelper helper(true);
502 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
503 SetDelayRunInHandler();
504 int32_t ret = g_coreService->SetShowName(0, u"", g_directCall);
505 g_coreService->simManager_ = nullptr;
506 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
507 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
508 }
509
510 HWTEST_F(CoreServiceTest, SetShowName006, Function | MediumTest | Level1)
511 {
512 TelephonyPermissionTestHelper helper(true);
513 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
514 SetRunInCaller();
515 EXPECT_CALL(*g_mockSimManager, SetShowName(_, _))
516 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
517 int32_t ret = g_coreService->SetShowName(0, u"", g_directCall);
518 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
519 }
520
521 /**************************************************** GetShowName ***************************************************/
522 HWTEST_F(CoreServiceTest, GetShowName001, Function | MediumTest | Level1)
523 {
524 TelephonyPermissionTestHelper helper(false);
525 int32_t ret = g_coreService->GetShowName(0, nullptr);
526 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
527 }
528
529 HWTEST_F(CoreServiceTest, GetShowName002, Function | MediumTest | Level1)
530 {
531 TelephonyPermissionTestHelper helper(true);
532 int32_t ret = g_coreService->GetShowName(0, nullptr);
533 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
534 }
535
536 HWTEST_F(CoreServiceTest, GetShowName003, Function | MediumTest | Level1)
537 {
538 TelephonyPermissionTestHelper helper(true);
539 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
540 g_coreService->simManager_ = nullptr;
541 int32_t ret = g_coreService->GetShowName(0, nullptr);
542 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
543 }
544
545 HWTEST_F(CoreServiceTest, GetShowName004, Function | MediumTest | Level1)
546 {
547 TelephonyPermissionTestHelper helper(true);
548 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
549 int32_t ret = g_coreService->GetShowName(0, nullptr);
550 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
551 }
552
553 HWTEST_F(CoreServiceTest, GetShowName005, Function | MediumTest | Level1)
554 {
555 TelephonyPermissionTestHelper helper(true);
556 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
557 SetDelayRunInHandler();
558 int32_t ret = g_coreService->GetShowName(0, g_directCall);
559 g_coreService->simManager_ = nullptr;
560 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
561 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
562 }
563
564 HWTEST_F(CoreServiceTest, GetShowName006, Function | MediumTest | Level1)
565 {
566 TelephonyPermissionTestHelper helper(true);
567 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
568 SetRunInCaller();
569 EXPECT_CALL(*g_mockSimManager, GetShowName(_, _))
570 .WillOnce(DoAll(
__anonec10c9d80202(int32_t, std::u16string &name) 571 Invoke([](int32_t, std::u16string &name) { name = u"TestName"; return TELEPHONY_ERR_SUCCESS; }),
572 Return(TELEPHONY_ERR_SUCCESS)));
573 int32_t ret = g_coreService->GetShowName(0, g_directCall);
574 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
575 }
576
577 /***************************************************** UnlockPin ****************************************************/
578 HWTEST_F(CoreServiceTest, UnlockPin001, Function | MediumTest | Level1)
579 {
580 TelephonyPermissionTestHelper helper(false);
581 int32_t ret = g_coreService->UnlockPin(0, u"", nullptr);
582 EXPECT_EQ(ret, TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
583 }
584
585 HWTEST_F(CoreServiceTest, UnlockPin002, Function | MediumTest | Level1)
586 {
587 TelephonyPermissionTestHelper helper(true);
588 int32_t ret = g_coreService->UnlockPin(0, u"", nullptr);
589 EXPECT_EQ(ret, TELEPHONY_ERR_PERMISSION_ERR);
590 }
591
592 HWTEST_F(CoreServiceTest, UnlockPin003, Function | MediumTest | Level1)
593 {
594 TelephonyPermissionTestHelper helper(true);
595 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
596 g_coreService->simManager_ = nullptr;
597 int32_t ret = g_coreService->UnlockPin(0, u"", nullptr);
598 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
599 }
600
601 HWTEST_F(CoreServiceTest, UnlockPin004, Function | MediumTest | Level1)
602 {
603 TelephonyPermissionTestHelper helper(true);
604 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
605 int32_t ret = g_coreService->UnlockPin(0, u"", nullptr);
606 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
607 }
608
609 HWTEST_F(CoreServiceTest, UnlockPin005, Function | MediumTest | Level1)
610 {
611 TelephonyPermissionTestHelper helper(true);
612 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
613 SetDelayRunInHandler();
614 int32_t ret = g_coreService->UnlockPin(0, u"", g_directCall);
615 g_coreService->simManager_ = nullptr;
616 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
617 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
618 }
619
620 HWTEST_F(CoreServiceTest, UnlockPin006, Function | MediumTest | Level1)
621 {
622 TelephonyPermissionTestHelper helper(true);
623 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
624 SetRunInCaller();
625 EXPECT_CALL(*g_mockSimManager, UnlockPin(_, _, _))
626 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
627 int32_t ret = g_coreService->UnlockPin(0, u"", g_directCall);
628 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
629 }
630
631 /***************************************************** UnlockPin2 ***************************************************/
632 HWTEST_F(CoreServiceTest, UnlockPin2001, Function | MediumTest | Level1)
633 {
634 TelephonyPermissionTestHelper helper(false);
635 int32_t ret = g_coreService->UnlockPin2(0, u"", nullptr);
636 EXPECT_EQ(ret, TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
637 }
638
639 HWTEST_F(CoreServiceTest, UnlockPin2002, Function | MediumTest | Level1)
640 {
641 TelephonyPermissionTestHelper helper(true);
642 int32_t ret = g_coreService->UnlockPin2(0, u"", nullptr);
643 EXPECT_EQ(ret, TELEPHONY_ERR_PERMISSION_ERR);
644 }
645
646 HWTEST_F(CoreServiceTest, UnlockPin2003, Function | MediumTest | Level1)
647 {
648 TelephonyPermissionTestHelper helper(true);
649 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
650 g_coreService->simManager_ = nullptr;
651 int32_t ret = g_coreService->UnlockPin2(0, u"", nullptr);
652 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
653 }
654
655 HWTEST_F(CoreServiceTest, UnlockPin2004, Function | MediumTest | Level1)
656 {
657 TelephonyPermissionTestHelper helper(true);
658 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
659 int32_t ret = g_coreService->UnlockPin2(0, u"", nullptr);
660 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
661 }
662
663 HWTEST_F(CoreServiceTest, UnlockPin2005, Function | MediumTest | Level1)
664 {
665 TelephonyPermissionTestHelper helper(true);
666 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
667 SetDelayRunInHandler();
668 int32_t ret = g_coreService->UnlockPin2(0, u"", g_directCall);
669 g_coreService->simManager_ = nullptr;
670 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
671 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
672 }
673
674 HWTEST_F(CoreServiceTest, UnlockPin2006, Function | MediumTest | Level1)
675 {
676 TelephonyPermissionTestHelper helper(true);
677 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
678 SetRunInCaller();
679 EXPECT_CALL(*g_mockSimManager, UnlockPin2(_, _, _))
680 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
681 int32_t ret = g_coreService->UnlockPin2(0, u"", g_directCall);
682 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
683 }
684
685 /******************************************************* UnlockPuk **************************************************/
686 HWTEST_F(CoreServiceTest, UnlockPuk001, Function | MediumTest | Level1)
687 {
688 TelephonyPermissionTestHelper helper(false);
689 int32_t ret = g_coreService->UnlockPuk(0, u"", u"", nullptr);
690 EXPECT_EQ(ret, TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
691 }
692
693 HWTEST_F(CoreServiceTest, UnlockPuk002, Function | MediumTest | Level1)
694 {
695 TelephonyPermissionTestHelper helper(true);
696 int32_t ret = g_coreService->UnlockPuk(0, u"", u"", nullptr);
697 EXPECT_EQ(ret, TELEPHONY_ERR_PERMISSION_ERR);
698 }
699
700 HWTEST_F(CoreServiceTest, UnlockPuk003, Function | MediumTest | Level1)
701 {
702 TelephonyPermissionTestHelper helper(true);
703 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
704 g_coreService->simManager_ = nullptr;
705 int32_t ret = g_coreService->UnlockPuk(0, u"", u"", nullptr);
706 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
707 }
708
709 HWTEST_F(CoreServiceTest, UnlockPuk004, Function | MediumTest | Level1)
710 {
711 TelephonyPermissionTestHelper helper(true);
712 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
713 int32_t ret = g_coreService->UnlockPuk(0, u"", u"", nullptr);
714 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
715 }
716
717 HWTEST_F(CoreServiceTest, UnlockPuk005, Function | MediumTest | Level1)
718 {
719 TelephonyPermissionTestHelper helper(true);
720 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
721 SetDelayRunInHandler();
722 int32_t ret = g_coreService->UnlockPuk(0, u"", u"", g_directCall);
723 g_coreService->simManager_ = nullptr;
724 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
725 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
726 }
727
728 HWTEST_F(CoreServiceTest, UnlockPuk006, Function | MediumTest | Level1)
729 {
730 TelephonyPermissionTestHelper helper(true);
731 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
732 SetRunInCaller();
733 EXPECT_CALL(*g_mockSimManager, UnlockPuk(_, _, _, _))
734 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
735 int32_t ret = g_coreService->UnlockPuk(0, u"1234", u"5678", g_directCall);
736 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
737 }
738
739 /******************************************************** UnlockPuk2 ************************************************/
740 HWTEST_F(CoreServiceTest, UnlockPuk2001, Function | MediumTest | Level1)
741 {
742 TelephonyPermissionTestHelper helper(false);
743 int32_t ret = g_coreService->UnlockPuk2(0, u"", u"", nullptr);
744 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
745 }
746
747 HWTEST_F(CoreServiceTest, UnlockPuk2002, Function | MediumTest | Level1)
748 {
749 TelephonyPermissionTestHelper helper(true);
750 int32_t ret = g_coreService->UnlockPuk2(0, u"", u"", nullptr);
751 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
752 }
753
754 HWTEST_F(CoreServiceTest, UnlockPuk2003, Function | MediumTest | Level1)
755 {
756 TelephonyPermissionTestHelper helper(true);
757 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
758 g_coreService->simManager_ = nullptr;
759 int32_t ret = g_coreService->UnlockPuk2(0, u"", u"", nullptr);
760 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
761 }
762
763 HWTEST_F(CoreServiceTest, UnlockPuk2004, Function | MediumTest | Level1)
764 {
765 TelephonyPermissionTestHelper helper(true);
766 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
767 int32_t ret = g_coreService->UnlockPuk2(0, u"", u"", nullptr);
768 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
769 }
770
771 HWTEST_F(CoreServiceTest, UnlockPuk2005, Function | MediumTest | Level1)
772 {
773 TelephonyPermissionTestHelper helper(true);
774 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
775 SetDelayRunInHandler();
776 int32_t ret = g_coreService->UnlockPuk2(0, u"", u"", g_directCall);
777 g_coreService->simManager_ = nullptr;
778 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
779 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
780 }
781
782 HWTEST_F(CoreServiceTest, UnlockPuk2006, Function | MediumTest | Level1)
783 {
784 TelephonyPermissionTestHelper helper(true);
785 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
786 SetRunInCaller();
787 EXPECT_CALL(*g_mockSimManager, UnlockPuk2(_, _, _, _))
788 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
789 int32_t ret = g_coreService->UnlockPuk2(0, u"", u"", g_directCall);
790 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
791 }
792
793 /***************************************************** AlterPin *****************************************************/
794 HWTEST_F(CoreServiceTest, AlterPin001, Function | MediumTest | Level1)
795 {
796 TelephonyPermissionTestHelper helper(false);
797 int32_t ret = g_coreService->AlterPin(0, u"", u"", nullptr);
798 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
799 }
800
801 HWTEST_F(CoreServiceTest, AlterPin002, Function | MediumTest | Level1)
802 {
803 TelephonyPermissionTestHelper helper(true);
804 int32_t ret = g_coreService->AlterPin(0, u"", u"", nullptr);
805 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
806 }
807
808 HWTEST_F(CoreServiceTest, AlterPin003, Function | MediumTest | Level1)
809 {
810 TelephonyPermissionTestHelper helper(true);
811 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
812 g_coreService->simManager_ = nullptr;
813 int32_t ret = g_coreService->AlterPin(0, u"", u"", nullptr);
814 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
815 }
816
817 HWTEST_F(CoreServiceTest, AlterPin004, Function | MediumTest | Level1)
818 {
819 TelephonyPermissionTestHelper helper(true);
820 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
821 int32_t ret = g_coreService->AlterPin(0, u"", u"", nullptr);
822 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
823 }
824
825 HWTEST_F(CoreServiceTest, AlterPin005, Function | MediumTest | Level1)
826 {
827 TelephonyPermissionTestHelper helper(true);
828 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
829 SetDelayRunInHandler();
830 int32_t ret = g_coreService->AlterPin(0, u"", u"", g_directCall);
831 g_coreService->simManager_ = nullptr;
832 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
833 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
834 }
835
836 HWTEST_F(CoreServiceTest, AlterPin006, Function | MediumTest | Level1)
837 {
838 TelephonyPermissionTestHelper helper(true);
839 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
840 SetRunInCaller();
841 EXPECT_CALL(*g_mockSimManager, AlterPin(_, _, _, _))
842 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
843 int32_t ret = g_coreService->AlterPin(0, u"", u"", g_directCall);
844 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
845 }
846
847 /***************************************************** AlterPin2 ****************************************************/
848 HWTEST_F(CoreServiceTest, AlterPin2001, Function | MediumTest | Level1)
849 {
850 TelephonyPermissionTestHelper helper(false);
851 int32_t ret = g_coreService->AlterPin2(0, u"", u"", nullptr);
852 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
853 }
854
855 HWTEST_F(CoreServiceTest, AlterPin2002, Function | MediumTest | Level1)
856 {
857 TelephonyPermissionTestHelper helper(true);
858 int32_t ret = g_coreService->AlterPin2(0, u"", u"", nullptr);
859 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
860 }
861
862 HWTEST_F(CoreServiceTest, AlterPin2003, Function | MediumTest | Level1)
863 {
864 TelephonyPermissionTestHelper helper(true);
865 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
866 g_coreService->simManager_ = nullptr;
867 int32_t ret = g_coreService->AlterPin2(0, u"", u"", nullptr);
868 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
869 }
870
871 HWTEST_F(CoreServiceTest, AlterPin2004, Function | MediumTest | Level1)
872 {
873 TelephonyPermissionTestHelper helper(true);
874 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
875 int32_t ret = g_coreService->AlterPin2(0, u"", u"", nullptr);
876 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
877 }
878
879 HWTEST_F(CoreServiceTest, AlterPin2005, Function | MediumTest | Level1)
880 {
881 TelephonyPermissionTestHelper helper(true);
882 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
883 SetDelayRunInHandler();
884 int32_t ret = g_coreService->AlterPin2(0, u"", u"", g_directCall);
885 g_coreService->simManager_ = nullptr;
886 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
887 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
888 }
889
890 HWTEST_F(CoreServiceTest, AlterPin2006, Function | MediumTest | Level1)
891 {
892 TelephonyPermissionTestHelper helper(true);
893 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
894 SetRunInCaller();
895 EXPECT_CALL(*g_mockSimManager, AlterPin2(_, _, _, _))
896 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
897 int32_t ret = g_coreService->AlterPin2(0, u"", u"", g_directCall);
898 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
899 }
900
901 /**************************************************** SetLockState **************************************************/
902 HWTEST_F(CoreServiceTest, SetLockState001, Function | MediumTest | Level1)
903 {
904 TelephonyPermissionTestHelper helper(false);
905 LockInfo options = {};
906 int32_t ret = g_coreService->SetLockState(0, options, nullptr);
907 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
908 }
909
910 HWTEST_F(CoreServiceTest, SetLockState002, Function | MediumTest | Level1)
911 {
912 TelephonyPermissionTestHelper helper(true);
913 LockInfo options = {};
914 int32_t ret = g_coreService->SetLockState(0, options, nullptr);
915 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
916 }
917
918 HWTEST_F(CoreServiceTest, SetLockState003, Function | MediumTest | Level1)
919 {
920 TelephonyPermissionTestHelper helper(true);
921 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
922 g_coreService->simManager_ = nullptr;
923 LockInfo options = {};
924 int32_t ret = g_coreService->SetLockState(0, options, nullptr);
925 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
926 }
927
928 HWTEST_F(CoreServiceTest, SetLockState004, Function | MediumTest | Level1)
929 {
930 TelephonyPermissionTestHelper helper(true);
931 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
932 LockInfo options = {};
933 int32_t ret = g_coreService->SetLockState(0, options, nullptr);
934 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
935 }
936
937 HWTEST_F(CoreServiceTest, SetLockState005, Function | MediumTest | Level1)
938 {
939 TelephonyPermissionTestHelper helper(true);
940 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
941 SetDelayRunInHandler();
942 LockInfo options = {};
943 int32_t ret = g_coreService->SetLockState(0, options, g_directCall);
944 g_coreService->simManager_ = nullptr;
945 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
946 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
947 }
948
949 HWTEST_F(CoreServiceTest, SetLockState006, Function | MediumTest | Level1)
950 {
951 TelephonyPermissionTestHelper helper(true);
952 helper.GrantPermission(Permission::SET_TELEPHONY_STATE);
953 SetRunInCaller();
954 LockInfo options = {};
955 EXPECT_CALL(*g_mockSimManager, SetLockState(_, _, _))
956 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
957 int32_t ret = g_coreService->SetLockState(0, options, g_directCall);
958 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
959 }
960
961 /**************************************************** GetLockState **************************************************/
962 HWTEST_F(CoreServiceTest, GetLockState001, Function | MediumTest | Level1)
963 {
964 TelephonyPermissionTestHelper helper(false);
965 int32_t ret = g_coreService->GetLockState(0, LockType::PIN_LOCK, nullptr);
966 EXPECT_TRUE(ret == TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
967 }
968
969 HWTEST_F(CoreServiceTest, GetLockState002, Function | MediumTest | Level1)
970 {
971 TelephonyPermissionTestHelper helper(true);
972 int32_t ret = g_coreService->GetLockState(0, LockType::PIN_LOCK, nullptr);
973 EXPECT_TRUE(ret == TELEPHONY_ERR_PERMISSION_ERR);
974 }
975
976 HWTEST_F(CoreServiceTest, GetLockState003, Function | MediumTest | Level1)
977 {
978 TelephonyPermissionTestHelper helper(true);
979 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
980 g_coreService->simManager_ = nullptr;
981 int32_t ret = g_coreService->GetLockState(0, LockType::PIN_LOCK, nullptr);
982 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
983 }
984
985 HWTEST_F(CoreServiceTest, GetLockState004, Function | MediumTest | Level1)
986 {
987 TelephonyPermissionTestHelper helper(true);
988 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
989 int32_t ret = g_coreService->GetLockState(0, LockType::PIN_LOCK, nullptr);
990 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
991 }
992
993 HWTEST_F(CoreServiceTest, GetLockState005, Function | MediumTest | Level1)
994 {
995 TelephonyPermissionTestHelper helper(true);
996 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
997 SetDelayRunInHandler();
998 int32_t ret = g_coreService->GetLockState(0, LockType::PIN_LOCK, g_directCall);
999 g_coreService->simManager_ = nullptr;
1000 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
1001 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1002 }
1003
1004 HWTEST_F(CoreServiceTest, GetLockState006, Function | MediumTest | Level1)
1005 {
1006 TelephonyPermissionTestHelper helper(true);
1007 helper.GrantPermission(Permission::GET_TELEPHONY_STATE);
1008 SetRunInCaller();
1009 EXPECT_CALL(*g_mockSimManager, GetLockState(_, _, _))
1010 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
1011 int32_t ret = g_coreService->GetLockState(0, LockType::PIN_LOCK, g_directCall);
1012 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1013 }
1014
1015 /***************************************************** HasSimCard ***************************************************/
1016 HWTEST_F(CoreServiceTest, HasSimCard001, Function | MediumTest | Level1)
1017 {
1018 g_coreService->simManager_ = nullptr;
1019 int32_t ret = g_coreService->HasSimCard(0, nullptr);
1020 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
1021 }
1022
1023 HWTEST_F(CoreServiceTest, HasSimCard002, Function | MediumTest | Level1)
1024 {
1025 int32_t ret = g_coreService->HasSimCard(0, nullptr);
1026 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
1027 }
1028
1029 HWTEST_F(CoreServiceTest, HasSimCard003, Function | MediumTest | Level1)
1030 {
1031 SetDelayRunInHandler();
1032 int32_t ret = g_coreService->HasSimCard(0, g_directCall);
1033 g_coreService->simManager_ = nullptr;
1034 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
1035 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1036 }
1037
1038 HWTEST_F(CoreServiceTest, HasSimCard004, Function | MediumTest | Level1)
1039 {
1040 SetRunInCaller();
1041 EXPECT_CALL(*g_mockSimManager, HasSimCard(_, _))
1042 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
1043 int32_t ret = g_coreService->HasSimCard(0, g_directCall);
1044 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1045 }
1046
1047 /***************************************************** GetSimState **************************************************/
1048 HWTEST_F(CoreServiceTest, GetSimState001, Function | MediumTest | Level1)
1049 {
1050 g_coreService->simManager_ = nullptr;
1051 int32_t ret = g_coreService->GetSimState(0, nullptr);
1052 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
1053 }
1054
1055 HWTEST_F(CoreServiceTest, GetSimState002, Function | MediumTest | Level1)
1056 {
1057 int32_t ret = g_coreService->GetSimState(0, nullptr);
1058 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
1059 }
1060
1061 HWTEST_F(CoreServiceTest, GetSimState003, Function | MediumTest | Level1)
1062 {
1063 SetDelayRunInHandler();
1064 int32_t ret = g_coreService->GetSimState(0, g_directCall);
1065 g_coreService->simManager_ = nullptr;
1066 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
1067 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1068 }
1069
1070 HWTEST_F(CoreServiceTest, GetSimState004, Function | MediumTest | Level1)
1071 {
1072 SetRunInCaller();
1073 EXPECT_CALL(*g_mockSimManager, GetSimState(_, _))
1074 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
1075 int32_t ret = g_coreService->GetSimState(0, g_directCall);
1076 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1077 }
1078
1079 /************************************************* HasOperatorPrivileges ********************************************/
1080 HWTEST_F(CoreServiceTest, HasOperatorPrivileges001, Function | MediumTest | Level1)
1081 {
1082 g_coreService->simManager_ = nullptr;
1083 int32_t ret = g_coreService->HasOperatorPrivileges(0, nullptr);
1084 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
1085 }
1086
1087 HWTEST_F(CoreServiceTest, HasOperatorPrivileges002, Function | MediumTest | Level1)
1088 {
1089 int32_t ret = g_coreService->HasOperatorPrivileges(0, nullptr);
1090 EXPECT_TRUE(ret == TELEPHONY_ERR_LOCAL_PTR_NULL);
1091 }
1092
1093 HWTEST_F(CoreServiceTest, HasOperatorPrivileges003, Function | MediumTest | Level1)
1094 {
1095 SetDelayRunInHandler();
1096 int32_t ret = g_coreService->HasOperatorPrivileges(0, g_directCall);
1097 g_coreService->simManager_ = nullptr;
1098 std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME_MS));
1099 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1100 }
1101
1102 HWTEST_F(CoreServiceTest, HasOperatorPrivileges004, Function | MediumTest | Level1)
1103 {
1104 SetRunInCaller();
1105 EXPECT_CALL(*g_mockSimManager, HasOperatorPrivileges(_, _))
1106 .WillOnce(Return(TELEPHONY_ERR_SUCCESS));
1107 int32_t ret = g_coreService->HasOperatorPrivileges(0, g_directCall);
1108 EXPECT_TRUE(ret == TELEPHONY_ERR_SUCCESS);
1109 }
1110 }
1111 }
1112 }