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
18 #include <string>
19 #include <unistd.h>
20 #include "gtest/gtest.h"
21 #include "sim_constant.h"
22 #include "sim_manager.h"
23 #include "core_manager_inner.h"
24 #include "core_service.h"
25 #include "core_service_client.h"
26 #include "enum_convert.h"
27
28 #include "multi_sim_controller.h"
29 #include "mock_sim_fil_manage.h"
30 #include "mock_multi_sim_controller.h"
31 #include "mock_sim_rdb_helper.h"
32 #include "tel_ril_manager.h"
33
34 namespace OHOS {
35 namespace Telephony {
36 using namespace testing::ext;
37 using namespace testing;
38 class MultiSimControllerTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44 };
45
46
SetUpTestCase()47 void MultiSimControllerTest::SetUpTestCase() {}
48
TearDownTestCase()49 void MultiSimControllerTest::TearDownTestCase() {}
50
SetUp()51 void MultiSimControllerTest::SetUp() {}
52
TearDown()53 void MultiSimControllerTest::TearDown() {}
54
55 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_Init_001, Function | MediumTest | Level1)
56 {
57 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
58 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
59 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
60 std::shared_ptr<Telephony::MultiSimController> multiSimController =
61 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
62 auto radioProtocolController =
63 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
64 multiSimController->simDbHelper_ = std::make_unique<SimRdbHelper>();
65 multiSimController->ResetDataShareError();
66 multiSimController->radioProtocolController_ = nullptr;
67 multiSimController->Init();
68 multiSimController->radioProtocolController_ = radioProtocolController;
69 multiSimController->GetRadioProtocol(1);
70 EXPECT_EQ(multiSimController->isSetActiveSimInProgress_.size(), SIM_SLOT_COUNT);
71 }
72
73 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_ForgetAllData_001, Function | MediumTest | Level1)
74 {
75 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
76 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
77 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
78 std::shared_ptr<Telephony::MultiSimController> multiSimController =
79 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
80 multiSimController->simDbHelper_ = nullptr;
81 bool ret = multiSimController->ForgetAllData();
82 multiSimController->ResetDataShareError();
83 EXPECT_FALSE(ret);
84 }
85
86 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_UpdateOpKeyInfo_001, Function | MediumTest | Level1)
87 {
88 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
89 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
90 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
91 std::shared_ptr<Telephony::MultiSimController> multiSimController =
92 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
93 multiSimController->simDbHelper_ = nullptr;
94 bool ret = multiSimController->UpdateOpKeyInfo();
95 multiSimController->simDbHelper_ = std::make_unique<SimRdbHelper>();
96 multiSimController->UpdateOpKeyInfo();
97 EXPECT_TRUE(ret);
98 multiSimController->simDbHelper_ = nullptr;
99 EXPECT_EQ(multiSimController->UpdateOpKeyInfo(), TELEPHONY_ERROR);
100 }
101
102 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InitData_001, Function | MediumTest | Level1)
103 {
104 int32_t slotId = DEFAULT_SIM_SLOT_ID - 1;
105 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
106 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
107 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
108 std::shared_ptr<Telephony::MultiSimController> multiSimController =
109 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
110 bool ret = multiSimController->InitData(slotId);
111 EXPECT_FALSE(ret);
112 }
113
114 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InitData_002, Function | MediumTest | Level1)
115 {
116 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
117 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
118 EventFwk::MatchingSkills matchingSkills;
119 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
120
121 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager;
122 simStateManager.push_back(simStateManager0);
123
124 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager0);
125 simFileManager->simFile_ = std::make_shared<SimFile>(simStateManager0);
126
127 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager_;
128 simFileManager_.push_back(simFileManager);
129
130 std::shared_ptr<Telephony::MultiSimController> multiSimController =
131 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager_);
132
133 std::vector<SimRdbInfo> newCache;
134 newCache.resize(2);
135 newCache[0].iccId = "2164181618486135";
136 newCache[1].iccId.clear();
137 multiSimController->localCacheInfo_ = newCache;
138
139 bool ret = multiSimController->InitData(0);
140 EXPECT_FALSE(ret);
141 }
142
143 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InitData_003, Function | MediumTest | Level1)
144 {
145 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
146 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
147 EventFwk::MatchingSkills matchingSkills;
148 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
149
150 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager;
151 simStateManager.push_back(simStateManager0);
152
153 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager0);
154 simFileManager->simFile_ = std::make_shared<SimFile>(simStateManager0);
155
156 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager_;
157 simFileManager_.push_back(simFileManager);
158
159 std::shared_ptr<Telephony::MultiSimController> multiSimController =
160 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager_);
161
162 std::vector<SimRdbInfo> newCache;
163 newCache.resize(2);
164 newCache[0].iccId = "2164181618486135";
165 newCache[1].iccId.clear();
166 multiSimController->localCacheInfo_ = newCache;
167
168 auto multiSimControllerMock = std::make_shared<MultiSimControllerMock>(telRilManager,
169 simStateManager, simFileManager_);
170 EXPECT_CALL(*multiSimControllerMock, InitIccId(0)).WillRepeatedly(Return(true));
171 EXPECT_CALL(*multiSimControllerMock, IsValidData(0)).WillRepeatedly(Return(true));
172
173 bool ret = multiSimController->InitData(0);
174 EXPECT_FALSE(ret);
175 }
176
177 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InitActive_001, Function | MediumTest | Level1)
178 {
179 int32_t slotId = 0;
180 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
181 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
182 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { simStateManager0, nullptr };
183 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
184 std::shared_ptr<Telephony::MultiSimController> multiSimController =
185 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
186 bool ret = multiSimController->InitActive(slotId);
187 EXPECT_TRUE(ret);
188 }
189
190 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_ReCheckPrimary_001, Function | MediumTest | Level1)
191 {
192 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
193 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
194 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { simStateManager0, nullptr };
195 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
196 std::shared_ptr<Telephony::MultiSimController> multiSimController =
197 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
198 multiSimController->maxCount_ = 1;
199 multiSimController->ReCheckPrimary();
200 EXPECT_NE(multiSimController->simStateManager_[0], nullptr);
201 }
202
203 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_IsAllCardsLoaded_001, Function | MediumTest | Level1)
204 {
205 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
206 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
207 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { simStateManager0, nullptr };
208 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
209 std::shared_ptr<Telephony::MultiSimController> multiSimController =
210 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
211 std::vector<SimRdbInfo> newCache;
212 newCache.resize(2);
213 newCache[0].iccId = "2164181618486135";
214 newCache[1].iccId.clear();
215 multiSimController->localCacheInfo_ = newCache;
216 bool ret = multiSimController->IsAllCardsLoaded();
217 EXPECT_FALSE(ret);
218 }
219
220 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_IsAllCardsLoaded_002, Function | MediumTest | Level1)
221 {
222 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
223 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
224 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { simStateManager0, nullptr };
225 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
226 std::shared_ptr<Telephony::MultiSimController> multiSimController =
227 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
228 std::vector<SimRdbInfo> newCache;
229 newCache.resize(2);
230 newCache[0].iccId = "2164181618486135";
231 newCache[1].iccId.clear();
232 multiSimController->localCacheInfo_ = newCache;
233 bool ret = multiSimController->IsAllCardsLoaded();
234 EXPECT_FALSE(ret);
235 }
236
237 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InitIccId_001, Function | MediumTest | Level1)
238 {
239 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
240 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
241 EventFwk::MatchingSkills matchingSkills;
242 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
243
244 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager;
245 simStateManager.push_back(simStateManager0);
246
247 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager0);
248 simFileManager->simFile_ = std::make_shared<SimFile>(simStateManager0);
249
250 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager_;
251 simFileManager_.push_back(simFileManager);
252
253 std::shared_ptr<Telephony::MultiSimController> multiSimController =
254 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager_);
255
256 std::vector<SimRdbInfo> newCache;
257 newCache.resize(2);
258 newCache[0].iccId = "2164181618486135";
259 newCache[1].iccId.clear();
260 multiSimController->localCacheInfo_ = newCache;
261
262 bool ret = multiSimController->InitIccId(0);
263 EXPECT_FALSE(ret);
264 }
265
266 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InitIccId_002, Function | MediumTest | Level1)
267 {
268 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
269 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
270 EventFwk::MatchingSkills matchingSkills;
271 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
272
273 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager;
274 simStateManager.push_back(simStateManager0);
275
276 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager0);
277 simFileManager->simFile_ = std::make_shared<SimFile>(simStateManager0);
278
279 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager_;
280 simFileManager_.push_back(simFileManager);
281
282 std::shared_ptr<Telephony::MultiSimController> multiSimController =
283 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager_);
284
285 std::vector<SimRdbInfo> newCache;
286 newCache.resize(2);
287 newCache[0].iccId = "2164181618486135";
288 newCache[1].iccId.clear();
289 multiSimController->localCacheInfo_ = newCache;
290
291 auto mockSimRdbHelper = std::make_shared<MockSimRdbHelper>();
292 EXPECT_CALL(*mockSimRdbHelper, QueryDataByIccId(_, _)).WillRepeatedly(Return(INVALID_VALUE));
293 multiSimController->simDbHelper_ = std::make_unique<SimRdbHelper>();
294 bool ret = multiSimController->InitIccId(0);
295 EXPECT_FALSE(ret);
296 }
297
298 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InitIccId_003, Function | MediumTest | Level1)
299 {
300 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
301 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
302 EventFwk::MatchingSkills matchingSkills;
303 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
304
305 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager;
306 simStateManager.push_back(simStateManager0);
307
308 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager0);
309 simFileManager->simFile_ = std::make_shared<SimFile>(simStateManager0);
310
311 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager_;
312 simFileManager_.push_back(simFileManager);
313
314 std::shared_ptr<Telephony::MultiSimController> multiSimController =
315 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager_);
316
317 std::vector<SimRdbInfo> newCache;
318 newCache.resize(2);
319 newCache[0].iccId = "2164181618486135";
320 newCache[1].iccId.clear();
321 multiSimController->localCacheInfo_ = newCache;
322
323 auto mockSimRdbHelper = std::make_shared<MockSimRdbHelper>();
324 EXPECT_CALL(*mockSimRdbHelper, QueryDataByIccId(_, _)).WillRepeatedly(Return(TELEPHONY_SUCCESS));
325 EXPECT_CALL(*mockSimRdbHelper, UpdateDataByIccId(_, _)).WillRepeatedly(Return(INVALID_VALUE));
326 multiSimController->simDbHelper_ = std::make_unique<SimRdbHelper>();
327 bool ret = multiSimController->InitIccId(0);
328 EXPECT_FALSE(ret);
329 }
330
331 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_GetShowNumber_001, Function | MediumTest | Level1)
332 {
333 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
334 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
335 simStateManager0->Init(0);
336 simStateManager0->simStateHandle_->iccState_.simStatus_ = ICC_CONTENT_READY;
337
338 auto simStateManager1 = std::make_shared<Telephony::SimStateManager>(telRilManager);
339 simStateManager1->Init(1);
340 simStateManager1->simStateHandle_->iccState_.simStatus_ = ICC_CONTENT_READY;
341
342 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager_ = { simStateManager0, simStateManager1 };
343 EventFwk::MatchingSkills matchingSkills;
344 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
345 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
346 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager0);
347 simFileManager->simFile_ = std::make_shared<SimFile>(simStateManager0);
348 simFileManager->simFile_->msisdn_ = "2164181618486135";
349 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager_ = { simFileManager, nullptr };
350 std::shared_ptr<Telephony::MultiSimController> multiSimController =
351 std::make_shared<MultiSimController>(telRilManager, simStateManager_, simFileManager_);
352 multiSimController->maxCount_ = 2;
353 multiSimController->Init();
354
355 std::vector<SimRdbInfo> newCache;
356 newCache.resize(1);
357 std::u16string showNumber = u"";
358 newCache[0].phoneNumber = "2164181618486135";
359 multiSimController->simStateManager_ = { simStateManager0, simStateManager1 };
360 multiSimController->localCacheInfo_ = newCache;
361 int32_t result = multiSimController->GetShowNumber(0, showNumber);
362 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
363 result = multiSimController->GetShowNumber(1, showNumber);
364
365 newCache[0].phoneNumber = "2164181618486139";
366 multiSimController->localCacheInfo_ = newCache;
367 result = multiSimController->GetShowNumber(0, showNumber);
368 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
369 }
370
371 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_UpdateDataByIccId_001, Function | MediumTest | Level1)
372 {
373 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
374 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
375 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
376 std::shared_ptr<Telephony::MultiSimController> multiSimController =
377 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
378 auto radioProtocolController =
379 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
380 radioProtocolController->Init();
381 multiSimController->simDbHelper_ = nullptr;
382
383 multiSimController->maxCount_ = 2;
384 multiSimController->Init();
385 auto ret = multiSimController->UpdateDataByIccId(0, "000011111");
386
387 multiSimController->simDbHelper_ = std::make_unique<SimRdbHelper>();
388 multiSimController->UpdateDataByIccId(1, "000011111");
389
390 EXPECT_EQ(ret, INVALID_VALUE);
391 }
392
393 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_InsertData_001, Function | MediumTest | Level1)
394 {
395 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
396 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
397 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
398 std::shared_ptr<Telephony::MultiSimController> multiSimController =
399 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
400 auto radioProtocolController =
401 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
402 multiSimController->simDbHelper_ = nullptr;
403
404 multiSimController->maxCount_ = 2;
405 multiSimController->Init();
406 auto ret = multiSimController->InsertData(0, "000011111");
407
408 multiSimController->simDbHelper_ = std::make_unique<SimRdbHelper>();
409 multiSimController->InsertData(1, "000011111");
410
411 multiSimController->UpdateSubState(0, 1);
412
413 EXPECT_EQ(ret, INVALID_VALUE);
414 }
415
416 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_SetPrimarySlotId_001, Function | MediumTest | Level1)
417 {
418 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
419 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
420 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
421 std::shared_ptr<Telephony::MultiSimController> multiSimController =
422 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
423 auto radioProtocolController =
424 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
425 multiSimController->simDbHelper_ = nullptr;
426
427 multiSimController->maxCount_ = 2;
428 multiSimController->Init();
429 auto ret = multiSimController->SetPrimarySlotId(0, false);
430
431 multiSimController->simDbHelper_ = std::make_unique<SimRdbHelper>();
432 multiSimController->SetPrimarySlotId(1, false);
433
434 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
435
436 multiSimController->isRilSetPrimarySlotSupport_ = true;
437 multiSimController->SetPrimarySlotId(1, true);
438 EXPECT_EQ(ret, TELEPHONY_ERR_NO_SIM_CARD);
439 }
440
441 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_SetPrimarySlotId_002, Function | MediumTest | Level1)
442 {
443 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
444 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
445 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
446 std::shared_ptr<Telephony::MultiSimController> multiSimController =
447 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
448 auto radioProtocolController =
449 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
450 multiSimController->simDbHelper_ = nullptr;
451 multiSimController->maxCount_ = 2;
452 multiSimController->Init();
453 multiSimController->isRilSetPrimarySlotSupport_ = true;
454 multiSimController->isSettingPrimarySlotToRil_ = true;
455 EXPECT_FALSE(multiSimController->SetPrimarySlotToRil(0));
456
457 multiSimController->isSettingPrimarySlotToRil_ = false;
458 telRilManager = nullptr;
459 multiSimController->SetPrimarySlotToRil(0);
460 multiSimController->SendSetPrimarySlotEvent(0);
461 }
462
463 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_ProcessEvent_001, Function | MediumTest | Level1)
464 {
465 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
466 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
467 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
468 std::shared_ptr<Telephony::MultiSimController> multiSimController =
469 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
470 auto radioProtocolController =
471 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
472 multiSimController->simDbHelper_ = nullptr;
473
474 multiSimController->maxCount_ = 2;
475 multiSimController->Init();
476 multiSimController->isRilSetPrimarySlotSupport_ = true;
477 AppExecFwk::InnerEvent::Pointer event1 = AppExecFwk::InnerEvent::
478 Get(RADIO_SIM_SET_PRIMARY_SLOT, 0);
479 multiSimController->ProcessEvent(event1);
480 AppExecFwk::InnerEvent::Pointer event2 = AppExecFwk::InnerEvent::
481 Get(RADIO_SIM_SET_PRIMARY_SLOT, 0);
482 multiSimController->ProcessEvent(event2);
483 auto nullEvent = AppExecFwk::InnerEvent::Pointer(nullptr, nullptr);
484 multiSimController->OnRilSetPrimarySlotDone(nullEvent);
485 multiSimController->OnRilSetPrimarySlotTimeout(nullEvent);
486 EXPECT_FALSE(multiSimController->setPrimarySlotResponseResult_);
487 }
488
489 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_SendMainCardBroadCast_001, Function | MediumTest | Level1)
490 {
491 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
492 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
493 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
494 std::shared_ptr<Telephony::MultiSimController> multiSimController =
495 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
496 auto radioProtocolController =
497 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
498 multiSimController->simDbHelper_ = nullptr;
499
500 multiSimController->maxCount_ = 2;
501 multiSimController->Init();
502 multiSimController->SendMainCardBroadCast(1);
503
504 std::vector<SimRdbInfo> newCache;
505 newCache.resize(2);
506 newCache[0].iccId = "2164181618486135";
507 newCache[1].iccId.clear();
508 multiSimController->localCacheInfo_ = newCache;
509 multiSimController->ResetSetPrimarySlotRemain(0);
510 multiSimController->ResetSetPrimarySlotRemain(-1);
511 multiSimController->ResetSetPrimarySlotRemain(5);
512 multiSimController->SendMainCardBroadCast(0);
513 multiSimController->SendDefaultCellularDataBroadCast(0);
514 EXPECT_EQ(multiSimController->localCacheInfo_.size(), 2);
515 }
516
517 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_GetSimTelephoneNumber_001, Function | MediumTest | Level1)
518 {
519 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
520 auto simStateManager0 = std::make_shared<Telephony::SimStateManager>(telRilManager);
521 simStateManager0->Init(0);
522 simStateManager0->simStateHandle_->iccState_.simStatus_ = ICC_CONTENT_READY;
523
524 auto simStateManager1 = std::make_shared<Telephony::SimStateManager>(telRilManager);
525 simStateManager1->Init(1);
526 simStateManager1->simStateHandle_->iccState_.simStatus_ = ICC_CONTENT_READY;
527
528 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager_ = { simStateManager0, simStateManager1 };
529 EventFwk::MatchingSkills matchingSkills;
530 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
531 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
532 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager0);
533 simFileManager->simFile_ = std::make_shared<SimFile>(simStateManager0);
534 simFileManager->simFile_->msisdn_ = "2164181618486135";
535 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager_ = { simFileManager, nullptr };
536 std::shared_ptr<Telephony::MultiSimController> multiSimController =
537 std::make_shared<MultiSimController>(telRilManager, simStateManager_, simFileManager_);
538 multiSimController->maxCount_ = 2;
539 multiSimController->Init();
540
541 std::vector<SimRdbInfo> newCache;
542 newCache.resize(1);
543 std::u16string showNumber = u"";
544 newCache[0].phoneNumber = "2164181618486135";
545 multiSimController->simStateManager_ = { simStateManager0, simStateManager1 };
546 multiSimController->localCacheInfo_ = newCache;
547 int32_t result = multiSimController->GetSimTelephoneNumber(0, showNumber);
548 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
549 result = multiSimController->GetSimTelephoneNumber(1, showNumber);
550
551 newCache[0].phoneNumber = "2164181618486139";
552 multiSimController->localCacheInfo_ = newCache;
553 result = multiSimController->GetSimTelephoneNumber(0, showNumber);
554 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
555 }
556
557 HWTEST_F(MultiSimControllerTest, BuildRadioProtocolForCommunication_001, Function | MediumTest | Level1)
558 {
559 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
560 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
561 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
562 std::shared_ptr<Telephony::MultiSimController> multiSimController =
563 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
564 auto radioProtocolController =
565 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
566 radioProtocolController->slotCount_ = 2;
567 radioProtocolController->Init();
568 radioProtocolController->BuildRadioProtocolForCommunication(
569 RadioProtocolPhase::RADIO_PROTOCOL_PHASE_CHECK, RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL);
570 EXPECT_EQ(multiSimController->localCacheInfo_.size(), 0);
571 }
572
573 HWTEST_F(MultiSimControllerTest, WhenForgetAllDataReturnsValidValue, Function | MediumTest | Level1)
574 {
575 MockSimRdbHelper mockSimRdbHelper;
576 EXPECT_CALL(mockSimRdbHelper, ForgetAllData())
577 .WillRepeatedly(Return(1));
578 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
579 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
580 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
581 std::shared_ptr<Telephony::MultiSimController> multiSimController =
582 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
583 EXPECT_FALSE(multiSimController->ForgetAllData());
584 }
585
586 HWTEST_F(MultiSimControllerTest, WhenForgetAllDataReturnsInvalidValue, Function | MediumTest | Level1)
587 {
588 MockSimRdbHelper mockSimRdbHelper;
589 EXPECT_CALL(mockSimRdbHelper, ForgetAllData())
590 .WillRepeatedly(Return(0));
591 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
592 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
593 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
594 std::shared_ptr<Telephony::MultiSimController> multiSimController =
595 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
596 EXPECT_FALSE(multiSimController->ForgetAllData());
597 }
598
599 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_SetActiveCommonSim_001, Function | MediumTest | Level1)
600 {
601 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
602 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
603 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
604 std::shared_ptr<Telephony::MultiSimController> multiSimController =
605 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
606 multiSimController->isSetActiveSimInProgress_.resize(2, 0);
607 multiSimController->radioProtocolController_ = nullptr;
608 multiSimController->SetActiveCommonSim(0, 1, false, 0);
609 int32_t result = multiSimController-> SetActiveCommonSim(0, 1, false, 0);
610 EXPECT_EQ(result, TELEPHONY_ERR_RIL_CMD_FAIL);
611 }
612
613 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_UpdataCacheSetActiveState_001, Function | MediumTest | Level1)
614 {
615 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
616 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
617 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
618 std::shared_ptr<Telephony::MultiSimController> multiSimController =
619 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
620 multiSimController->isSetActiveSimInProgress_.resize(2, 0);
621 multiSimController->radioProtocolController_ = nullptr;
622 auto result = multiSimController->UpdataCacheSetActiveState(0, 1, 0);
623 EXPECT_EQ(result, TELEPHONY_ERR_RIL_CMD_FAIL);
624
625 std::vector<SimRdbInfo> newCache;
626 newCache.resize(2);
627 newCache[0].iccId = "2164181618486135";
628 newCache[1].iccId.clear();
629 multiSimController->localCacheInfo_ = newCache;
630
631 result = multiSimController->UpdataCacheSetActiveState(0, 1, 0);
632 }
633
634 HWTEST_F(MultiSimControllerTest, MultiSimControllerTest_UpdateDBSetActiveResult_001, Function | MediumTest | Level1)
635 {
636 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
637 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
638 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
639 std::shared_ptr<Telephony::MultiSimController> multiSimController =
640 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
641 multiSimController->isSetActiveSimInProgress_.resize(2, 0);
642 multiSimController->radioProtocolController_ = nullptr;
643 auto result = multiSimController->UpdateDBSetActiveResult(0, 1, 0);
644 EXPECT_EQ(result, TELEPHONY_ERR_RIL_CMD_FAIL);
645
646 std::vector<SimRdbInfo> newCache;
647 newCache.resize(2);
648 newCache[0].iccId = "2164181618486135";
649 newCache[1].iccId.clear();
650 multiSimController->localCacheInfo_ = newCache;
651
652 result = multiSimController->UpdateDBSetActiveResult(0, 1, 0);
653 }
654 }
655 }
656