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 #define private public
16 #define protected public
17 #include <gtest/gtest.h>
18
19 #include "core_manager_inner.h"
20 #include "mock_sim_manager.h"
21 #include "string_ex.h"
22 #include "sim_constant.h"
23
24 namespace OHOS {
25 namespace Telephony {
26 using namespace testing;
27 using namespace testing::ext;
28 class CoreManagerInnerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp();
33 void TearDown();
34
35 CoreManagerInner mInner;
36 std::shared_ptr<MockSimManager> mockeSimManager = std::make_shared<MockSimManager>();
37 };
38
SetUpTestCase()39 void CoreManagerInnerTest::SetUpTestCase() {}
40
TearDownTestCase()41 void CoreManagerInnerTest::TearDownTestCase() {}
42
SetUp()43 void CoreManagerInnerTest::SetUp() {}
44
TearDown()45 void CoreManagerInnerTest::TearDown() {}
46
47 HWTEST_F(CoreManagerInnerTest, ObtainSpnCondition_001, Function | MediumTest | Level1)
48 {
49 mInner.simManager_ = nullptr;
50 int32_t slotId = 0;
51 bool roaming = true;
52 std::string operatorNum;
53 int32_t ret = mInner.ObtainSpnCondition(slotId, roaming, operatorNum);
54 EXPECT_EQ(ret, 0);
55
56 mInner.simManager_ = mockeSimManager;
57 EXPECT_CALL(*mockeSimManager, ObtainSpnCondition(_, _, _)).WillOnce(
58 Return(SpnShowType::SPN_CONDITION_DISPLAY_PLMN));
59 ret = mInner.ObtainSpnCondition(slotId, roaming, operatorNum);
60 EXPECT_EQ(ret, SpnShowType::SPN_CONDITION_DISPLAY_PLMN);
61 }
62
63 HWTEST_F(CoreManagerInnerTest, GetSimSpn_001, Function | MediumTest | Level1)
64 {
65 mInner.simManager_ = nullptr;
66 int32_t slotId = 0;
67 std::u16string spn;
68 int32_t ret = mInner.GetSimSpn(slotId, spn);
69 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
70
71 mInner.simManager_ = mockeSimManager;
72 EXPECT_CALL(*mockeSimManager, GetSimSpn(_, _)).WillOnce(
73 Return(TELEPHONY_ERR_SUCCESS));
74 ret = mInner.GetSimSpn(slotId, spn);
75 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
76 }
77
78 HWTEST_F(CoreManagerInnerTest, GetSimEons_001, Function | MediumTest | Level1)
79 {
80 mInner.simManager_ = nullptr;
81 int32_t slotId = 0;
82 std::string plmn;
83 int32_t lac = 1;;
84 bool longNameRequired = true;
85 std::u16string ret = mInner.GetSimEons(slotId, plmn, lac, longNameRequired);
86 EXPECT_EQ(ret, u"");
87
88 mInner.simManager_ = mockeSimManager;
89 EXPECT_CALL(*mockeSimManager, GetSimEons(_, _, _, _)).WillOnce(
90 Return(u""));
91 ret = mInner.GetSimEons(slotId, plmn, lac, longNameRequired);
92 EXPECT_EQ(ret, u"");
93 }
94
95 HWTEST_F(CoreManagerInnerTest, SetVoiceMailInfo_001, Function | MediumTest | Level1)
96 {
97 mInner.simManager_ = nullptr;
98 int32_t slotId = 0;
99 std::u16string mailName;
100 std::u16string mailNumber;
101 int32_t ret = mInner.SetVoiceMailInfo(slotId, mailName, mailNumber);
102 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
103
104 mInner.simManager_ = mockeSimManager;
105 EXPECT_CALL(*mockeSimManager, SetVoiceMailInfo(_, _, _)).WillOnce(
106 Return(TELEPHONY_ERR_SUCCESS));
107 ret = mInner.SetVoiceMailInfo(slotId, mailName, mailNumber);
108 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
109 }
110
111 HWTEST_F(CoreManagerInnerTest, QueryIccDiallingNumbers_001, Function | MediumTest | Level1)
112 {
113 mInner.simManager_ = nullptr;
114 int slotId = 0;
115 int type = 1;
116 std::vector<std::shared_ptr<DiallingNumbersInfo>> result;
117 int32_t ret = mInner.QueryIccDiallingNumbers(slotId, type, result);
118 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
119
120 mInner.simManager_ = mockeSimManager;
121 EXPECT_CALL(*mockeSimManager, QueryIccDiallingNumbers(_, _, _)).WillOnce(
122 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
123 ret = mInner.QueryIccDiallingNumbers(slotId, type, result);
124 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
125 }
126
127 HWTEST_F(CoreManagerInnerTest, AddIccDiallingNumbers_001, Function | MediumTest | Level1)
128 {
129 mInner.simManager_ = nullptr;
130 int slotId = 0;
131 int type = 1;
132 std::shared_ptr<DiallingNumbersInfo> diallingNumber;
133 int32_t ret = mInner.AddIccDiallingNumbers(slotId, type, diallingNumber);
134 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
135
136 mInner.simManager_ = mockeSimManager;
137 EXPECT_CALL(*mockeSimManager, AddIccDiallingNumbers(_, _, _)).WillOnce(
138 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
139 ret = mInner.AddIccDiallingNumbers(slotId, type, diallingNumber);
140 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
141 }
142
143 HWTEST_F(CoreManagerInnerTest, DelIccDiallingNumbers_001, Function | MediumTest | Level1)
144 {
145 mInner.simManager_ = nullptr;
146 int slotId = 0;
147 int type = 1;
148 std::shared_ptr<DiallingNumbersInfo> diallingNumber;
149 int32_t ret = mInner.DelIccDiallingNumbers(slotId, type, diallingNumber);
150 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
151
152 mInner.simManager_ = mockeSimManager;
153 EXPECT_CALL(*mockeSimManager, DelIccDiallingNumbers(_, _, _)).WillOnce(
154 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
155 ret = mInner.DelIccDiallingNumbers(slotId, type, diallingNumber);
156 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
157 }
158
159 HWTEST_F(CoreManagerInnerTest, UpdateIccDiallingNumbers_001, Function | MediumTest | Level1)
160 {
161 mInner.simManager_ = nullptr;
162 int slotId = 0;
163 int type = 1;
164 std::shared_ptr<DiallingNumbersInfo> diallingNumber;
165 int32_t ret = mInner.UpdateIccDiallingNumbers(slotId, type, diallingNumber);
166 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
167
168 mInner.simManager_ = mockeSimManager;
169 EXPECT_CALL(*mockeSimManager, UpdateIccDiallingNumbers(_, _, _)).WillOnce(
170 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
171 ret = mInner.UpdateIccDiallingNumbers(slotId, type, diallingNumber);
172 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
173 }
174
175 HWTEST_F(CoreManagerInnerTest, AddSmsToIcc_001, Function | MediumTest | Level1)
176 {
177 mInner.simManager_ = nullptr;
178 int slotId = 0;
179 int status = 1;
180 std::string pdu;
181 std::string smsc;
182 int32_t ret = mInner.AddSmsToIcc(slotId, status, pdu, smsc);
183 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
184
185 mInner.simManager_ = mockeSimManager;
186 EXPECT_CALL(*mockeSimManager, AddSmsToIcc(_, _, _, _)).WillOnce(
187 Return(TELEPHONY_ERR_SLOTID_INVALID));
188 ret = mInner.AddSmsToIcc(slotId, status, pdu, smsc);
189 EXPECT_EQ(ret, TELEPHONY_ERR_SLOTID_INVALID);
190 }
191
192 HWTEST_F(CoreManagerInnerTest, UpdateSmsIcc_001, Function | MediumTest | Level1)
193 {
194 mInner.simManager_ = nullptr;
195 int slotId = 0;
196 int index = 1;
197 int status = 1;
198 std::string pduData;
199 std::string smsc;
200 int32_t ret = mInner.UpdateSmsIcc(slotId, index, status, pduData, smsc);
201 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
202
203 mInner.simManager_ = mockeSimManager;
204 EXPECT_CALL(*mockeSimManager, UpdateSmsIcc(_, _, _, _, _)).WillOnce(
205 Return(TELEPHONY_ERR_SLOTID_INVALID));
206 ret = mInner.UpdateSmsIcc(slotId, index, status, pduData, smsc);
207 EXPECT_EQ(ret, TELEPHONY_ERR_SLOTID_INVALID);
208 }
209
210 HWTEST_F(CoreManagerInnerTest, ObtainAllSmsOfIcc_001, Function | MediumTest | Level1)
211 {
212 mInner.simManager_ = nullptr;
213 int slotId = 0;
214 std::vector<std::string> ret = mInner.ObtainAllSmsOfIcc(slotId);
215 EXPECT_TRUE(ret.empty());
216
217 mInner.simManager_ = mockeSimManager;
218 EXPECT_CALL(*mockeSimManager, ObtainAllSmsOfIcc(_)).WillOnce(
219 Return(std::vector<std::string>()));
220 ret = mInner.ObtainAllSmsOfIcc(slotId);
221 EXPECT_TRUE(ret.empty());
222 }
223
224 HWTEST_F(CoreManagerInnerTest, DelSmsIcc_001, Function | MediumTest | Level1)
225 {
226 mInner.simManager_ = nullptr;
227 int slotId = 0;
228 int index = 1;
229 int32_t ret = mInner.DelSmsIcc(slotId, index);
230 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
231
232 mInner.simManager_ = mockeSimManager;
233 EXPECT_CALL(*mockeSimManager, DelSmsIcc(_, _)).WillOnce(
234 Return(TELEPHONY_ERR_SLOTID_INVALID));
235 ret = mInner.DelSmsIcc(slotId, index);
236 EXPECT_EQ(ret, TELEPHONY_ERR_SLOTID_INVALID);
237 }
238
239 HWTEST_F(CoreManagerInnerTest, IsSimActive_001, Function | MediumTest | Level1)
240 {
241 mInner.simManager_ = nullptr;
242 int slotId = 0;
243 bool ret = mInner.IsSimActive(slotId);
244 EXPECT_FALSE(ret);
245
246 mInner.simManager_ = mockeSimManager;
247 EXPECT_CALL(*mockeSimManager, IsSimActive(_)).WillOnce(
248 Return(true));
249 ret = mInner.IsSimActive(slotId);
250 EXPECT_TRUE(ret);
251 }
252
253 HWTEST_F(CoreManagerInnerTest, SetActiveSim_001, Function | MediumTest | Level1)
254 {
255 mInner.simManager_ = nullptr;
256 int32_t slotId = 0;
257 int32_t enable = 1;
258 int32_t ret = mInner.SetActiveSim(slotId, enable);
259 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
260
261 mInner.simManager_ = mockeSimManager;
262 EXPECT_CALL(*mockeSimManager, SetActiveSim(_, _)).WillOnce(
263 Return(TELEPHONY_ERR_SUCCESS));
264 ret = mInner.SetActiveSim(slotId, enable);
265 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
266 }
267
268 HWTEST_F(CoreManagerInnerTest, ResetSimLoadAccount_001, Function | MediumTest | Level1)
269 {
270 mInner.simManager_ = nullptr;
271 int32_t slotId = 0;
272 int32_t ret = mInner.ResetSimLoadAccount(slotId);
273 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
274
275 mInner.simManager_ = mockeSimManager;
276 EXPECT_CALL(*mockeSimManager, ResetSimLoadAccount(_)).WillOnce(
277 Return(TELEPHONY_ERR_SUCCESS));
278 ret = mInner.ResetSimLoadAccount(slotId);
279 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
280 }
281
282 HWTEST_F(CoreManagerInnerTest, GetSimAccountInfo_001, Function | MediumTest | Level1)
283 {
284 mInner.simManager_ = nullptr;
285 int32_t slotId = 0;
286 IccAccountInfo info;
287 int32_t ret = mInner.GetSimAccountInfo(slotId, info);
288 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
289
290 mInner.simManager_ = mockeSimManager;
291 EXPECT_CALL(*mockeSimManager, GetSimAccountInfo(_, _, _)).WillOnce(
292 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
293 ret = mInner.GetSimAccountInfo(slotId, info);
294 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
295 }
296
297 HWTEST_F(CoreManagerInnerTest, SetDefaultVoiceSlotId_001, Function | MediumTest | Level1)
298 {
299 mInner.simManager_ = nullptr;
300 int32_t slotId = 0;
301 int32_t ret = mInner.SetDefaultVoiceSlotId(slotId);
302 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
303
304 mInner.simManager_ = mockeSimManager;
305 EXPECT_CALL(*mockeSimManager, SetDefaultVoiceSlotId(_)).WillOnce(
306 Return(TELEPHONY_ERR_SUCCESS));
307 ret = mInner.SetDefaultVoiceSlotId(slotId);
308 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
309 }
310
311 HWTEST_F(CoreManagerInnerTest, SetDefaultSmsSlotId_001, Function | MediumTest | Level1)
312 {
313 mInner.simManager_ = nullptr;
314 int32_t slotId = 0;
315 int32_t ret = mInner.SetDefaultSmsSlotId(slotId);
316 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
317
318 mInner.simManager_ = mockeSimManager;
319 EXPECT_CALL(*mockeSimManager, SetDefaultSmsSlotId(_)).WillOnce(
320 Return(TELEPHONY_ERR_SUCCESS));
321 ret = mInner.SetDefaultSmsSlotId(slotId);
322 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
323 }
324
325 HWTEST_F(CoreManagerInnerTest, SetDefaultCellularDataSlotId_001, Function | MediumTest | Level1)
326 {
327 mInner.simManager_ = nullptr;
328 int32_t slotId = 0;
329 int32_t ret = mInner.SetDefaultCellularDataSlotId(slotId);
330 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
331
332 mInner.simManager_ = mockeSimManager;
333 EXPECT_CALL(*mockeSimManager, SetDefaultCellularDataSlotId(_)).WillOnce(
334 Return(TELEPHONY_ERR_SUCCESS));
335 ret = mInner.SetDefaultCellularDataSlotId(slotId);
336 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
337 }
338
339 HWTEST_F(CoreManagerInnerTest, SetPrimarySlotId_001, Function | MediumTest | Level1)
340 {
341 mInner.simManager_ = nullptr;
342 int32_t slotId = 0;
343 bool isUserSet = true;
344 int32_t ret = mInner.SetPrimarySlotId(slotId, isUserSet);
345 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
346
347 mInner.simManager_ = mockeSimManager;
348 EXPECT_CALL(*mockeSimManager, SetPrimarySlotId(_, _)).WillOnce(
349 Return(TELEPHONY_ERR_SUCCESS));
350 ret = mInner.SetPrimarySlotId(slotId, isUserSet);
351 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
352 }
353
354 HWTEST_F(CoreManagerInnerTest, SetShowNumber_001, Function | MediumTest | Level1)
355 {
356 mInner.simManager_ = nullptr;
357 int32_t slotId = 0;
358 std::u16string number;
359 int32_t ret = mInner.SetShowNumber(slotId, number);
360 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
361
362 mInner.simManager_ = mockeSimManager;
363 EXPECT_CALL(*mockeSimManager, SetShowNumber(_, _)).WillOnce(
364 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
365 ret = mInner.SetShowNumber(slotId, number);
366 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
367 }
368
369 HWTEST_F(CoreManagerInnerTest, SetShowName_001, Function | MediumTest | Level1)
370 {
371 mInner.simManager_ = nullptr;
372 int32_t slotId = 0;
373 std::u16string name;
374 int32_t ret = mInner.SetShowName(slotId, name);
375 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
376
377 mInner.simManager_ = mockeSimManager;
378 EXPECT_CALL(*mockeSimManager, SetShowName(_, _)).WillOnce(
379 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
380 ret = mInner.SetShowName(slotId, name);
381 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
382 }
383
384 HWTEST_F(CoreManagerInnerTest, GetDefaultVoiceSlotId_001, Function | MediumTest | Level1)
385 {
386 mInner.simManager_ = nullptr;
387 int32_t ret = mInner.GetDefaultVoiceSlotId();
388 EXPECT_EQ(ret, TELEPHONY_ERROR);
389
390 mInner.simManager_ = mockeSimManager;
391 EXPECT_CALL(*mockeSimManager, GetDefaultVoiceSlotId()).WillOnce(
392 Return(DEFAULT_SIM_SLOT_ID));
393 ret = mInner.GetDefaultVoiceSlotId();
394 EXPECT_EQ(ret, DEFAULT_SIM_SLOT_ID);
395 }
396
397 HWTEST_F(CoreManagerInnerTest, GetDefaultVoiceSimId_001, Function | MediumTest | Level1)
398 {
399 mInner.simManager_ = nullptr;
400 int32_t simId = 0;
401 int32_t ret = mInner.GetDefaultVoiceSimId(simId);
402 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
403
404 mInner.simManager_ = mockeSimManager;
405 EXPECT_CALL(*mockeSimManager, GetDefaultVoiceSimId(_)).WillOnce(
406 Return(TELEPHONY_ERR_SUCCESS));
407 ret = mInner.GetDefaultVoiceSimId(simId);
408 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
409 }
410
411 HWTEST_F(CoreManagerInnerTest, GetDefaultSmsSlotId_001, Function | MediumTest | Level1)
412 {
413 mInner.simManager_ = nullptr;
414 int32_t ret = mInner.GetDefaultSmsSlotId();
415 EXPECT_EQ(ret, TELEPHONY_ERROR);
416
417 mInner.simManager_ = mockeSimManager;
418 EXPECT_CALL(*mockeSimManager, GetDefaultSmsSlotId()).WillOnce(
419 Return(DEFAULT_SIM_SLOT_ID));
420 ret = mInner.GetDefaultSmsSlotId();
421 EXPECT_EQ(ret, DEFAULT_SIM_SLOT_ID);
422 }
423
424 HWTEST_F(CoreManagerInnerTest, GetDefaultSmsSimId_001, Function | MediumTest | Level1)
425 {
426 mInner.simManager_ = nullptr;
427 int32_t simId = 0;
428 int32_t ret = mInner.GetDefaultSmsSimId(simId);
429 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
430
431 mInner.simManager_ = mockeSimManager;
432 EXPECT_CALL(*mockeSimManager, GetDefaultSmsSimId(_)).WillOnce(
433 Return(TELEPHONY_ERR_SUCCESS));
434 ret = mInner.GetDefaultSmsSimId(simId);
435 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
436 }
437
438 HWTEST_F(CoreManagerInnerTest, GetDefaultCellularDataSlotId_001, Function | MediumTest | Level1)
439 {
440 mInner.simManager_ = nullptr;
441 int32_t ret = mInner.GetDefaultCellularDataSlotId();
442 EXPECT_EQ(ret, TELEPHONY_ERROR);
443
444 mInner.simManager_ = mockeSimManager;
445 EXPECT_CALL(*mockeSimManager, GetDefaultCellularDataSlotId()).WillOnce(
446 Return(DEFAULT_SIM_SLOT_ID));
447 ret = mInner.GetDefaultCellularDataSlotId();
448 EXPECT_EQ(ret, DEFAULT_SIM_SLOT_ID);
449 }
450
451 HWTEST_F(CoreManagerInnerTest, GetDefaultCellularDataSimId_001, Function | MediumTest | Level1)
452 {
453 mInner.simManager_ = nullptr;
454 int32_t simId = 0;
455 int32_t ret = mInner.GetDefaultCellularDataSimId(simId);
456 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
457
458 mInner.simManager_ = mockeSimManager;
459 EXPECT_CALL(*mockeSimManager, GetDefaultCellularDataSimId(_)).WillOnce(
460 Return(TELEPHONY_ERR_SUCCESS));
461 ret = mInner.GetDefaultCellularDataSimId(simId);
462 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
463 }
464
465 HWTEST_F(CoreManagerInnerTest, GetDsdsMode_001, Function | MediumTest | Level1)
466 {
467 mInner.simManager_ = nullptr;
468 int32_t dsdsMode = 0;
469 int32_t ret = mInner.GetDsdsMode(dsdsMode);
470 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
471
472 mInner.simManager_ = mockeSimManager;
473 EXPECT_CALL(*mockeSimManager, GetDsdsMode(_)).WillOnce(
474 Return(TELEPHONY_ERR_SUCCESS));
475 ret = mInner.GetDsdsMode(dsdsMode);
476 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
477 }
478
479 HWTEST_F(CoreManagerInnerTest, SetDsdsMode_001, Function | MediumTest | Level1)
480 {
481 mInner.simManager_ = nullptr;
482 int32_t dsdsMode = 0;
483 int32_t ret = mInner.SetDsdsMode(dsdsMode);
484 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
485
486 mInner.simManager_ = mockeSimManager;
487 EXPECT_CALL(*mockeSimManager, SetDsdsMode(_)).WillOnce(
488 Return(TELEPHONY_ERR_SUCCESS));
489 ret = mInner.SetDsdsMode(dsdsMode);
490 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
491 }
492
493 HWTEST_F(CoreManagerInnerTest, GetShowNumber_001, Function | MediumTest | Level1)
494 {
495 mInner.simManager_ = nullptr;
496 int32_t slotId = 0;
497 std::u16string showNumber;
498 int32_t ret = mInner.GetShowNumber(slotId, showNumber);
499 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
500
501 mInner.simManager_ = mockeSimManager;
502 EXPECT_CALL(*mockeSimManager, GetShowNumber(_, _)).WillOnce(
503 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
504 ret = mInner.GetShowNumber(slotId, showNumber);
505 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
506 }
507
508 HWTEST_F(CoreManagerInnerTest, GetShowName_001, Function | MediumTest | Level1)
509 {
510 mInner.simManager_ = nullptr;
511 int32_t slotId = 0;
512 std::u16string showName;
513 int32_t ret = mInner.GetShowName(slotId, showName);
514 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
515
516 mInner.simManager_ = mockeSimManager;
517 EXPECT_CALL(*mockeSimManager, GetShowName(_, _)).WillOnce(
518 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
519 ret = mInner.GetShowName(slotId, showName);
520 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
521 }
522
523 HWTEST_F(CoreManagerInnerTest, GetActiveSimAccountInfoList_001, Function | MediumTest | Level1)
524 {
525 mInner.simManager_ = nullptr;
526 std::vector<IccAccountInfo> iccAccountInfoList;
527 int32_t ret = mInner.GetActiveSimAccountInfoList(iccAccountInfoList);
528 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
529
530 ret = mInner.UpdateOperatorConfigs();
531 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
532
533 mInner.simManager_ = mockeSimManager;
534 EXPECT_CALL(*mockeSimManager, GetActiveSimAccountInfoList(_, _)).WillOnce(
535 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
536 ret = mInner.GetActiveSimAccountInfoList(iccAccountInfoList);
537 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
538 }
539
540 HWTEST_F(CoreManagerInnerTest, GetLocaleFromDefaultSim_001, Function | MediumTest | Level1)
541 {
542 mInner.simManager_ = nullptr;
543 int32_t slotId = 0;
544 std::u16string ret = mInner.GetLocaleFromDefaultSim(slotId);
545 EXPECT_EQ(ret, u"");
546
547 mInner.simManager_ = mockeSimManager;
548 EXPECT_CALL(*mockeSimManager, GetLocaleFromDefaultSim(_)).WillOnce(
549 Return(u""));
550 ret = mInner.GetLocaleFromDefaultSim(slotId);
551 EXPECT_EQ(ret, u"");
552 }
553
554 HWTEST_F(CoreManagerInnerTest, GetSlotId_001, Function | MediumTest | Level1)
555 {
556 mInner.simManager_ = nullptr;
557 int32_t slotId = 0;
558 std::int32_t ret = mInner.GetSlotId(slotId);
559 EXPECT_EQ(ret, TELEPHONY_ERROR);
560
561 mInner.simManager_ = mockeSimManager;
562 EXPECT_CALL(*mockeSimManager, GetSlotId(_)).WillOnce(
563 Return(TELEPHONY_ERROR));
564 ret = mInner.GetSlotId(slotId);
565 EXPECT_EQ(ret, TELEPHONY_ERROR);
566 }
567
568 HWTEST_F(CoreManagerInnerTest, GetSimGid1_001, Function | MediumTest | Level1)
569 {
570 mInner.simManager_ = nullptr;
571 int32_t slotId = 0;
572 std::u16string gid1;
573 int32_t ret = mInner.GetSimGid1(slotId, gid1);
574 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
575
576 mInner.simManager_ = mockeSimManager;
577 EXPECT_CALL(*mockeSimManager, GetSimGid1(_, _)).WillOnce(
578 Return(TELEPHONY_ERR_SUCCESS));
579 ret = mInner.GetSimGid1(slotId, gid1);
580 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
581 }
582
583 HWTEST_F(CoreManagerInnerTest, GetSimGid2_001, Function | MediumTest | Level1)
584 {
585 mInner.simManager_ = nullptr;
586 int32_t slotId = 0;
587 std::u16string ret = mInner.GetSimGid2(slotId);
588 EXPECT_EQ(ret, u"");
589
590 mInner.simManager_ = mockeSimManager;
591 EXPECT_CALL(*mockeSimManager, GetSimGid2(_)).WillOnce(
592 Return(u""));
593 ret = mInner.GetSimGid2(slotId);
594 EXPECT_EQ(ret, u"");
595 }
596
597 HWTEST_F(CoreManagerInnerTest, GetOpKeyExt_001, Function | MediumTest | Level1)
598 {
599 mInner.simManager_ = nullptr;
600 int32_t slotId = 0;
601 std::u16string opkeyExt;
602 int32_t ret = mInner.GetOpKeyExt(slotId, opkeyExt);
603 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
604
605 mInner.simManager_ = mockeSimManager;
606 EXPECT_CALL(*mockeSimManager, GetOpKeyExt(_, _)).WillOnce(
607 Return(TELEPHONY_ERR_SUCCESS));
608 ret = mInner.GetOpKeyExt(slotId, opkeyExt);
609 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
610 }
611
612 HWTEST_F(CoreManagerInnerTest, GetOpKey_001, Function | MediumTest | Level1)
613 {
614 mInner.simManager_ = nullptr;
615 std::u16string opkey;
616 int32_t ret = mInner.GetOpKey(opkey);
617 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
618
619 mInner.simManager_ = mockeSimManager;
620 EXPECT_CALL(*mockeSimManager, GetOpKey(_, _)).WillOnce(
621 Return(TELEPHONY_ERR_SUCCESS));
622 ret = mInner.GetOpKey(opkey);
623 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
624 }
625
626 HWTEST_F(CoreManagerInnerTest, GetOpKey_002, Function | MediumTest | Level1)
627 {
628 mInner.simManager_ = nullptr;
629 int32_t slotId = 0;
630 std::u16string opkey;
631 int32_t ret = mInner.GetOpKey(slotId, opkey);
632 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
633
634 mInner.simManager_ = mockeSimManager;
635 EXPECT_CALL(*mockeSimManager, GetOpKey(_, _)).WillOnce(
636 Return(TELEPHONY_ERR_SUCCESS));
637 ret = mInner.GetOpKey(slotId, opkey);
638 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
639 }
640
641 HWTEST_F(CoreManagerInnerTest, GetSimTelephoneNumber_001, Function | MediumTest | Level1)
642 {
643 mInner.simManager_ = nullptr;
644 int32_t slotId = 0;
645 std::u16string telephoneNumber;
646 int32_t ret = mInner.GetSimTelephoneNumber(slotId, telephoneNumber);
647 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
648
649 mInner.simManager_ = mockeSimManager;
650 EXPECT_CALL(*mockeSimManager, GetSimTelephoneNumber(_, _)).WillOnce(
651 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
652 ret = mInner.GetSimTelephoneNumber(slotId, telephoneNumber);
653 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
654 }
655
656 HWTEST_F(CoreManagerInnerTest, GetSimTeleNumberIdentifier_001, Function | MediumTest | Level1)
657 {
658 mInner.simManager_ = nullptr;
659 int32_t slotId = 0;
660 std::u16string telephoneNumber;
661 std::u16string ret = mInner.GetSimTeleNumberIdentifier(slotId);
662 EXPECT_EQ(ret, u"");
663
664 mInner.simManager_ = mockeSimManager;
665 EXPECT_CALL(*mockeSimManager, GetSimTeleNumberIdentifier(_)).WillOnce(
666 Return(u""));
667 ret = mInner.GetSimTeleNumberIdentifier(slotId);
668 EXPECT_EQ(ret, u"");
669 }
670
671 HWTEST_F(CoreManagerInnerTest, GetVoiceMailIdentifier_001, Function | MediumTest | Level1)
672 {
673 mInner.simManager_ = nullptr;
674 int32_t slotId = 0;
675 std::u16string voiceMailIdentifier;
676 int32_t ret = mInner.GetVoiceMailIdentifier(slotId, voiceMailIdentifier);
677 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
678
679 mInner.simManager_ = mockeSimManager;
680 EXPECT_CALL(*mockeSimManager, GetVoiceMailIdentifier(_, _)).WillOnce(
681 Return(TELEPHONY_ERR_SUCCESS));
682 ret = mInner.GetVoiceMailIdentifier(slotId, voiceMailIdentifier);
683 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
684 }
685
686 HWTEST_F(CoreManagerInnerTest, GetVoiceMailNumber_001, Function | MediumTest | Level1)
687 {
688 mInner.simManager_ = nullptr;
689 int32_t slotId = 0;
690 std::u16string voiceMailNumber;
691 int32_t ret = mInner.GetVoiceMailNumber(slotId, voiceMailNumber);
692 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
693
694 mInner.simManager_ = mockeSimManager;
695 EXPECT_CALL(*mockeSimManager, GetVoiceMailNumber(_, _)).WillOnce(
696 Return(TELEPHONY_ERR_SUCCESS));
697 ret = mInner.GetVoiceMailNumber(slotId, voiceMailNumber);
698 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
699 }
700
701 HWTEST_F(CoreManagerInnerTest, GetVoiceMailCount_001, Function | MediumTest | Level1)
702 {
703 mInner.simManager_ = nullptr;
704 int32_t slotId = 0;
705 int32_t voiceMailCount;
706 int32_t ret = mInner.GetVoiceMailCount(slotId, voiceMailCount);
707 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
708
709 mInner.simManager_ = mockeSimManager;
710 EXPECT_CALL(*mockeSimManager, GetVoiceMailCount(_, _)).WillOnce(
711 Return(TELEPHONY_ERR_SUCCESS));
712 ret = mInner.GetVoiceMailCount(slotId, voiceMailCount);
713 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
714 }
715
716 HWTEST_F(CoreManagerInnerTest, SetVoiceMailCount_001, Function | MediumTest | Level1)
717 {
718 mInner.simManager_ = nullptr;
719 int32_t slotId = 0;
720 int32_t voiceMailCount = 0;
721 int32_t ret = mInner.SetVoiceMailCount(slotId, voiceMailCount);
722 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
723
724 mInner.simManager_ = mockeSimManager;
725 EXPECT_CALL(*mockeSimManager, SetVoiceMailCount(_, _)).WillOnce(
726 Return(TELEPHONY_ERR_SUCCESS));
727 ret = mInner.SetVoiceMailCount(slotId, voiceMailCount);
728 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
729 }
730
731 HWTEST_F(CoreManagerInnerTest, SetVoiceCallForwarding_001, Function | MediumTest | Level1)
732 {
733 mInner.simManager_ = nullptr;
734 int32_t slotId = 0;
735 bool enable = true;
736 std::string number;
737 int32_t ret = mInner.SetVoiceCallForwarding(slotId, enable, number);
738 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
739
740 mInner.simManager_ = mockeSimManager;
741 EXPECT_CALL(*mockeSimManager, SetVoiceCallForwarding(_, _, _)).WillOnce(
742 Return(TELEPHONY_ERR_SUCCESS));
743 ret = mInner.SetVoiceCallForwarding(slotId, enable, number);
744 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
745 }
746
747 HWTEST_F(CoreManagerInnerTest, GetSimIccStatus_001, Function | MediumTest | Level1)
748 {
749 mInner.simManager_ = nullptr;
750 int32_t slotId = 0;
751 IccSimStatus iccStatus;
752 int32_t ret = mInner.GetSimIccStatus(slotId, iccStatus);
753 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
754
755 mInner.simManager_ = mockeSimManager;
756 EXPECT_CALL(*mockeSimManager, GetSimIccStatus(_, _)).WillOnce(
757 Return(TELEPHONY_ERR_SUCCESS));
758 ret = mInner.GetSimIccStatus(slotId, iccStatus);
759 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
760 }
761
762 HWTEST_F(CoreManagerInnerTest, GetCardType_001, Function | MediumTest | Level1)
763 {
764 mInner.simManager_ = nullptr;
765 int32_t slotId = 0;
766 CardType cardType;
767 int32_t ret = mInner.GetCardType(slotId, cardType);
768 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
769
770 mInner.simManager_ = mockeSimManager;
771 EXPECT_CALL(*mockeSimManager, GetCardType(_, _)).WillOnce(
772 Return(TELEPHONY_ERR_SUCCESS));
773 ret = mInner.GetCardType(slotId, cardType);
774 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
775 }
776
777 HWTEST_F(CoreManagerInnerTest, UnlockPin_001, Function | MediumTest | Level1)
778 {
779 mInner.simManager_ = nullptr;
780 int32_t slotId = 0;
781 std::string pin;
782 LockStatusResponse response;
783 int32_t ret = mInner.UnlockPin(slotId, pin, response);
784 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
785
786 mInner.simManager_ = mockeSimManager;
787 EXPECT_CALL(*mockeSimManager, UnlockPin(_, _, _)).WillOnce(
788 Return(TELEPHONY_ERR_NO_SIM_CARD));
789 ret = mInner.UnlockPin(slotId, pin, response);
790 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
791 }
792
793 HWTEST_F(CoreManagerInnerTest, UnlockPuk_001, Function | MediumTest | Level1)
794 {
795 mInner.simManager_ = nullptr;
796 int32_t slotId = 0;
797 std::string newPin;
798 std::string puk;
799 LockStatusResponse response;
800 int32_t ret = mInner.UnlockPuk(slotId, newPin, puk, response);
801 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
802
803 mInner.simManager_ = mockeSimManager;
804 EXPECT_CALL(*mockeSimManager, UnlockPuk(_, _, _, _)).WillOnce(
805 Return(TELEPHONY_ERR_NO_SIM_CARD));
806 ret = mInner.UnlockPuk(slotId, newPin, puk, response);
807 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
808 }
809
810 HWTEST_F(CoreManagerInnerTest, AlterPin_001, Function | MediumTest | Level1)
811 {
812 mInner.simManager_ = nullptr;
813 int32_t slotId = 0;
814 std::string newPin;
815 std::string oldPin;
816 LockStatusResponse response;
817 int32_t ret = mInner.AlterPin(slotId, newPin, oldPin, response);
818 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
819
820 mInner.simManager_ = mockeSimManager;
821 EXPECT_CALL(*mockeSimManager, AlterPin(_, _, _, _)).WillOnce(
822 Return(TELEPHONY_ERR_NO_SIM_CARD));
823 ret = mInner.AlterPin(slotId, newPin, oldPin, response);
824 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
825 }
826
827 HWTEST_F(CoreManagerInnerTest, SendEnvelopeCmd_001, Function | MediumTest | Level1)
828 {
829 mInner.simManager_ = nullptr;
830 int32_t slotId = 0;
831 std::string cmd;
832 int32_t ret = mInner.SendEnvelopeCmd(slotId, cmd);
833 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
834
835 mInner.simManager_ = mockeSimManager;
836 EXPECT_CALL(*mockeSimManager, SendEnvelopeCmd(_, _)).WillOnce(
837 Return(TELEPHONY_ERR_NO_SIM_CARD));
838 ret = mInner.SendEnvelopeCmd(slotId, cmd);
839 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
840 }
841
842 HWTEST_F(CoreManagerInnerTest, SendTerminalResponseCmd_001, Function | MediumTest | Level1)
843 {
844 mInner.simManager_ = nullptr;
845 int32_t slotId = 0;
846 std::string cmd;
847 int32_t ret = mInner.SendTerminalResponseCmd(slotId, cmd);
848 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
849
850 mInner.simManager_ = mockeSimManager;
851 EXPECT_CALL(*mockeSimManager, SendTerminalResponseCmd(_, _)).WillOnce(
852 Return(TELEPHONY_ERR_NO_SIM_CARD));
853 ret = mInner.SendTerminalResponseCmd(slotId, cmd);
854 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
855 }
856
857 HWTEST_F(CoreManagerInnerTest, SendCallSetupRequestResult_001, Function | MediumTest | Level1)
858 {
859 mInner.simManager_ = nullptr;
860 int32_t slotId = 0;
861 bool accept = true;
862 int32_t ret = mInner.SendCallSetupRequestResult(slotId, accept);
863 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
864
865 mInner.simManager_ = mockeSimManager;
866 EXPECT_CALL(*mockeSimManager, SendCallSetupRequestResult(_, _)).WillOnce(
867 Return(TELEPHONY_ERR_NO_SIM_CARD));
868 ret = mInner.SendCallSetupRequestResult(slotId, accept);
869 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
870 }
871
872 HWTEST_F(CoreManagerInnerTest, UnlockSimLock_001, Function | MediumTest | Level1)
873 {
874 mInner.simManager_ = nullptr;
875 int32_t slotId = 0;
876 PersoLockInfo lockInfo;
877 LockStatusResponse response;
878 int32_t ret = mInner.UnlockSimLock(slotId, lockInfo, response);
879 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
880
881 mInner.simManager_ = mockeSimManager;
882 EXPECT_CALL(*mockeSimManager, UnlockSimLock(_, _, _)).WillOnce(
883 Return(TELEPHONY_ERR_NO_SIM_CARD));
884 ret = mInner.UnlockSimLock(slotId, lockInfo, response);
885 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
886 }
887
888 HWTEST_F(CoreManagerInnerTest, HasOperatorPrivileges_001, Function | MediumTest | Level1)
889 {
890 mInner.simManager_ = nullptr;
891 int32_t slotId = 0;
892 bool hasOperatorPrivileges = true;
893 int32_t ret = mInner.HasOperatorPrivileges(slotId, hasOperatorPrivileges);
894 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
895
896 mInner.simManager_ = mockeSimManager;
897 EXPECT_CALL(*mockeSimManager, HasOperatorPrivileges(_, _)).WillOnce(
898 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
899 ret = mInner.HasOperatorPrivileges(slotId, hasOperatorPrivileges);
900 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
901 }
902
903 HWTEST_F(CoreManagerInnerTest, GetSimIst_001, Function | MediumTest | Level1)
904 {
905 mInner.simManager_ = nullptr;
906 int32_t slotId = 0;
907 std::u16string ret = mInner.GetSimIst(slotId);
908 EXPECT_TRUE(ret.empty());
909
910 mInner.simManager_ = mockeSimManager;
911 EXPECT_CALL(*mockeSimManager, GetSimIst(_)).WillOnce(
912 Return(u""));
913 ret = mInner.GetSimIst(slotId);
914 EXPECT_TRUE(ret.empty());
915 }
916
917 HWTEST_F(CoreManagerInnerTest, SaveImsSwitch_001, Function | MediumTest | Level1)
918 {
919 mInner.simManager_ = nullptr;
920 int32_t slotId = 0;
921 int32_t imsSwitchValue = 1;
922 int32_t ret = mInner.SaveImsSwitch(slotId, imsSwitchValue);
923 EXPECT_EQ(ret, TELEPHONY_ERROR);
924
925 mInner.simManager_ = mockeSimManager;
926 EXPECT_CALL(*mockeSimManager, SaveImsSwitch(_, _)).WillOnce(
927 Return(TELEPHONY_ERR_ARGUMENT_INVALID));
928 ret = mInner.SaveImsSwitch(slotId, imsSwitchValue);
929 EXPECT_EQ(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
930 }
931
932 HWTEST_F(CoreManagerInnerTest, GetAllSimAccountInfoList_001, Function | MediumTest | Level1)
933 {
934 mInner.simManager_ = nullptr;
935 std::vector<IccAccountInfo> iccAccountInfoList;
936 int32_t ret = mInner.GetAllSimAccountInfoList(iccAccountInfoList);
937 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
938
939 mInner.simManager_ = mockeSimManager;
940 EXPECT_CALL(*mockeSimManager, GetAllSimAccountInfoList(_, _)).WillOnce(
941 Return(TELEPHONY_ERR_LOCAL_PTR_NULL));
942 ret = mInner.GetAllSimAccountInfoList(iccAccountInfoList);
943 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
944 }
945
946 HWTEST_F(CoreManagerInnerTest, GetSimLabel_001, Function | MediumTest | Level1)
947 {
948 mInner.simManager_ = nullptr;
949 int32_t slotId = 0;
950 SimLabel simLabel;
951 int32_t ret = mInner.GetSimLabel(slotId, simLabel);
952 EXPECT_EQ(ret, INVALID_VALUE);
953
954 mInner.simManager_ = mockeSimManager;
955 EXPECT_CALL(*mockeSimManager, GetSimLabel(_, _)).WillOnce(
956 Return(TELEPHONY_ERR_SUCCESS));
957 ret = mInner.GetSimLabel(slotId, simLabel);
958 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
959 }
960
961 HWTEST_F(CoreManagerInnerTest, SetSimLabelIndex_001, Function | MediumTest | Level1)
962 {
963 mInner.simManager_ = nullptr;
964 std::string iccId;
965 int32_t labelIndex = 1;
966 int32_t ret = mInner.SetSimLabelIndex(iccId, labelIndex);
967 EXPECT_EQ(ret, INVALID_VALUE);
968
969 mInner.simManager_ = mockeSimManager;
970 EXPECT_CALL(*mockeSimManager, SetSimLabelIndex(_, _)).WillOnce(
971 Return(TELEPHONY_ERR_SUCCESS));
972 ret = mInner.SetSimLabelIndex(iccId, labelIndex);
973 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
974 }
975
976 HWTEST_F(CoreManagerInnerTest, InsertEsimData_001, Function | MediumTest | Level1)
977 {
978 mInner.simManager_ = nullptr;
979 std::string iccId;
980 int32_t esimLabel = 1;
981 std::string operatorName;
982 int32_t ret = mInner.InsertEsimData(iccId, esimLabel, operatorName);
983 EXPECT_EQ(ret, INVALID_VALUE);
984
985 mInner.simManager_ = mockeSimManager;
986 EXPECT_CALL(*mockeSimManager, InsertEsimData(_, _, _)).WillOnce(
987 Return(TELEPHONY_ERR_SUCCESS));
988 ret = mInner.InsertEsimData(iccId, esimLabel, operatorName);
989 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
990 }
991
992 HWTEST_F(CoreManagerInnerTest, NotifySimSlotsMapping_001, Function | MediumTest | Level1)
993 {
994 mInner.simManager_ = nullptr;
995 int32_t slotId = 0;
996 int32_t ret = mInner.NotifySimSlotsMapping(slotId);
997 EXPECT_EQ(ret, INVALID_VALUE);
998
999 mInner.simManager_ = mockeSimManager;
1000 EXPECT_CALL(*mockeSimManager, NotifySimSlotsMapping(_)).WillOnce(
1001 Return(TELEPHONY_ERR_NO_SIM_CARD));
1002 ret = mInner.NotifySimSlotsMapping(slotId);
1003 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
1004 }
1005
1006 } // Telephony
1007 } // OHOS