1 /*
2 * Copyright (C) 2024 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
21 #include "common_event_manager.h"
22 #include "common_event_support.h"
23 #include "sim_file_manager.h"
24 #include "tel_ril_manager.h"
25 #include "gtest/gtest.h"
26
27 namespace OHOS {
28 namespace Telephony {
29 using namespace testing::ext;
30
31 class EsimFileManagerTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
TearDownTestCase()39 void EsimFileManagerTest::TearDownTestCase() {}
40
SetUp()41 void EsimFileManagerTest::SetUp() {}
42
TearDown()43 void EsimFileManagerTest::TearDown() {}
44
SetUpTestCase()45 void EsimFileManagerTest::SetUpTestCase() {}
46
47 HWTEST_F(EsimFileManagerTest, GetEid_001, Function | MediumTest | Level2)
48 {
49 std::string expectedEid = "";
50 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
51 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
52 EventFwk::MatchingSkills matchingSkills;
53 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
54 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
55 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
56 std::weak_ptr<SimStateManager>(simStateManager) };
57 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
58 EXPECT_EQ(simFileManager.GetEid(), Str8ToStr16(expectedEid));
59 simFileManager.eSimFile_ = nullptr;
60 EXPECT_EQ(simFileManager.GetEid(), u"");
61 }
62
63 HWTEST_F(EsimFileManagerTest, GetEuiccProfileInfoList_001, Function | MediumTest | Level2)
64 {
65 std::string expectedEid = "12345";
66 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
67 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
68 EventFwk::MatchingSkills matchingSkills;
69 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
70 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
71 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
72 std::weak_ptr<SimStateManager>(simStateManager) };
73 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
74 GetEuiccProfileInfoListInnerResult eUiccRes = simFileManager.GetEuiccProfileInfoList();
75 EXPECT_EQ(eUiccRes.result_, static_cast<int32_t>(ResultCode::RESULT_OK));
76 simFileManager.eSimFile_ = nullptr;
77 eUiccRes = simFileManager.GetEuiccProfileInfoList();
78 EXPECT_EQ(eUiccRes.result_, static_cast<int32_t>(ResultCode::RESULT_OK));
79 }
80
81 HWTEST_F(EsimFileManagerTest, GetEuiccInfo_001, Function | MediumTest | Level2)
82 {
83 std::string expectedEid = "12345";
84 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
85 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
86 EventFwk::MatchingSkills matchingSkills;
87 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
88 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
89 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
90 std::weak_ptr<SimStateManager>(simStateManager) };
91 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
92 EuiccInfo eUiccInfo = simFileManager.GetEuiccInfo();
93 EXPECT_EQ(eUiccInfo.osVersion_, u"");
94 simFileManager.eSimFile_ = nullptr;
95 eUiccInfo = simFileManager.GetEuiccInfo();
96 EXPECT_EQ(eUiccInfo.osVersion_, u"");
97 }
98
99 HWTEST_F(EsimFileManagerTest, DisableProfile_001, Function | MediumTest | Level2)
100 {
101 std::string expectedEid = "12345";
102 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
103 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
104 EventFwk::MatchingSkills matchingSkills;
105 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
106 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
107 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
108 std::weak_ptr<SimStateManager>(simStateManager) };
109 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
110 int32_t portIndex = 0;
111 std::u16string iccId = u"";
112 int32_t res = simFileManager.DisableProfile(portIndex, iccId);
113 EXPECT_NE(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
114 simFileManager.eSimFile_ = nullptr;
115 res = simFileManager.DisableProfile(portIndex, iccId);
116 EXPECT_EQ(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
117 }
118
119 HWTEST_F(EsimFileManagerTest, GetSmdsAddress_001, Function | MediumTest | Level2)
120 {
121 std::string expectedEid = "12345";
122 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
123 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
124 EventFwk::MatchingSkills matchingSkills;
125 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
126 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
127 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
128 std::weak_ptr<SimStateManager>(simStateManager) };
129 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
130 int32_t portIndex = 0;
131 std::u16string resStr = simFileManager.GetSmdsAddress(portIndex);
132 EXPECT_EQ(resStr, u"");
133 simFileManager.eSimFile_ = nullptr;
134 resStr = simFileManager.GetSmdsAddress(portIndex);
135 EXPECT_EQ(resStr, u"");
136 }
137
138 HWTEST_F(EsimFileManagerTest, GetRulesAuthTable_001, Function | MediumTest | Level2)
139 {
140 std::string expectedEid = "12345";
141 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
142 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
143 EventFwk::MatchingSkills matchingSkills;
144 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
145 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
146 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
147 std::weak_ptr<SimStateManager>(simStateManager) };
148 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
149 int32_t portIndex = 0;
150 EuiccRulesAuthTable res = simFileManager.GetRulesAuthTable(portIndex);
151 EXPECT_EQ(res.position_, 0);
152 simFileManager.eSimFile_ = nullptr;
153 res = simFileManager.GetRulesAuthTable(portIndex);
154 EXPECT_EQ(res.position_, 0);
155 }
156
157 HWTEST_F(EsimFileManagerTest, GetEuiccChallenge_001, Function | MediumTest | Level2)
158 {
159 std::string expectedEid = "12345";
160 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
161 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
162 EventFwk::MatchingSkills matchingSkills;
163 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
164 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
165 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
166 std::weak_ptr<SimStateManager>(simStateManager) };
167 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
168 int32_t portIndex = 0;
169 ResponseEsimInnerResult res = simFileManager.GetEuiccChallenge(portIndex);
170 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
171 simFileManager.eSimFile_ = nullptr;
172 res = simFileManager.GetEuiccChallenge(portIndex);
173 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
174 }
175
176 HWTEST_F(EsimFileManagerTest, RequestDefaultSmdpAddress_001, Function | MediumTest | Level2)
177 {
178 std::string expectedEid = "12345";
179 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
180 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
181 EventFwk::MatchingSkills matchingSkills;
182 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
183 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
184 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
185 std::weak_ptr<SimStateManager>(simStateManager) };
186 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
187 std::u16string resStr = simFileManager.GetDefaultSmdpAddress();
188 EXPECT_EQ(resStr, u"");
189 simFileManager.eSimFile_ = nullptr;
190 resStr = simFileManager.GetDefaultSmdpAddress();
191 EXPECT_EQ(resStr, u"");
192 }
193
194 HWTEST_F(EsimFileManagerTest, CancelSession_001, Function | MediumTest | Level2)
195 {
196 std::string expectedEid = "12345";
197 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
198 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
199 EventFwk::MatchingSkills matchingSkills;
200 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
201 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
202 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
203 std::weak_ptr<SimStateManager>(simStateManager) };
204 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
205 std::u16string transactionId = u"";
206 CancelReason cancelReason = CancelReason::CANCEL_REASON_END_USER_REJECTION;
207 ResponseEsimInnerResult res = simFileManager.CancelSession(transactionId, cancelReason);
208 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
209 simFileManager.eSimFile_ = nullptr;
210 res = simFileManager.CancelSession(transactionId, cancelReason);
211 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
212 }
213
214 HWTEST_F(EsimFileManagerTest, GetProfile_001, Function | MediumTest | Level2)
215 {
216 std::string expectedEid = "12345";
217 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
218 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
219 EventFwk::MatchingSkills matchingSkills;
220 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
221 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
222 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
223 std::weak_ptr<SimStateManager>(simStateManager) };
224 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
225 int32_t portIndex = 0;
226 std::u16string iccId = u"";
227 EuiccProfile res = simFileManager.GetProfile(portIndex, iccId);
228 EXPECT_EQ(res.state_, ProfileState::PROFILE_STATE_DISABLED);
229 simFileManager.eSimFile_ = nullptr;
230 res = simFileManager.GetProfile(portIndex, iccId);
231 EXPECT_EQ(res.state_, ProfileState::PROFILE_STATE_DISABLED);
232 }
233
234 HWTEST_F(EsimFileManagerTest, ResetMemory_001, Function | MediumTest | Level2)
235 {
236 std::string expectedEid = "12345";
237 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
238 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
239 EventFwk::MatchingSkills matchingSkills;
240 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
241 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
242 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
243 std::weak_ptr<SimStateManager>(simStateManager) };
244 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
245 ResetOption resetOption = ResetOption::DELETE_OPERATIONAL_PROFILES;
246 int32_t res = simFileManager.ResetMemory(resetOption);
247 EXPECT_NE(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
248 simFileManager.eSimFile_ = nullptr;
249 res = simFileManager.ResetMemory(resetOption);
250 EXPECT_EQ(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
251 }
252
253 HWTEST_F(EsimFileManagerTest, SetDefaultSmdpAddress_001, Function | MediumTest | Level2)
254 {
255 std::string expectedEid = "12345";
256 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
257 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
258 EventFwk::MatchingSkills matchingSkills;
259 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
260 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
261 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
262 std::weak_ptr<SimStateManager>(simStateManager) };
263 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
264 std::u16string defaultSmdpAddress = u"";
265 int32_t res = simFileManager.SetDefaultSmdpAddress(defaultSmdpAddress);
266 EXPECT_NE(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
267 simFileManager.eSimFile_ = nullptr;
268 res = simFileManager.SetDefaultSmdpAddress(defaultSmdpAddress);
269 EXPECT_EQ(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
270 }
271
272 HWTEST_F(EsimFileManagerTest, IsSupported_001, Function | MediumTest | Level2)
273 {
274 std::string expectedEid = "12345";
275 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
276 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
277 EventFwk::MatchingSkills matchingSkills;
278 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
279 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
280 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
281 std::weak_ptr<SimStateManager>(simStateManager) };
282 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
283 bool res = simFileManager.IsSupported();
284 EXPECT_EQ(res, false);
285 simFileManager.eSimFile_ = nullptr;
286 res = simFileManager.IsSupported();
287 EXPECT_EQ(res, false);
288 }
289
290 HWTEST_F(EsimFileManagerTest, SendApduData_001, Function | MediumTest | Level2)
291 {
292 std::string expectedEid = "12345";
293 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
294 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
295 EventFwk::MatchingSkills matchingSkills;
296 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
297 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
298 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
299 std::weak_ptr<SimStateManager>(simStateManager) };
300 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
301 std::u16string aid = u"";
302 EsimApduData apduData;
303 ResponseEsimInnerResult res = simFileManager.SendApduData(aid, apduData);
304 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
305 simFileManager.eSimFile_ = nullptr;
306 res = simFileManager.SendApduData(aid, apduData);
307 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
308 }
309
310 HWTEST_F(EsimFileManagerTest, PrepareDownload_001, Function | MediumTest | Level2)
311 {
312 std::string expectedEid = "12345";
313 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
314 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
315 EventFwk::MatchingSkills matchingSkills;
316 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
317 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
318 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
319 std::weak_ptr<SimStateManager>(simStateManager) };
320 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
321 DownLoadConfigInfo downLoadConfigInfo;
322 downLoadConfigInfo.portIndex_ = 0;
323 downLoadConfigInfo.hashCc_ = u"";
324 ResponseEsimInnerResult res = simFileManager.PrepareDownload(downLoadConfigInfo);
325 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
326
327 simFileManager.eSimFile_ = nullptr;
328 res = simFileManager.PrepareDownload(downLoadConfigInfo);
329 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
330 }
331
332 HWTEST_F(EsimFileManagerTest, LoadBoundProfilePackage_001, Function | MediumTest | Level2)
333 {
334 std::string expectedEid = "12345";
335 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
336 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
337 EventFwk::MatchingSkills matchingSkills;
338 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
339 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
340 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
341 std::weak_ptr<SimStateManager>(simStateManager) };
342 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
343 int32_t portIndex = 0;
344 std::u16string boundProfilePackage = u"";
345 ResponseEsimBppResult res = simFileManager.LoadBoundProfilePackage(portIndex, boundProfilePackage);
346 EXPECT_EQ(res.resultCode_, 0);
347 simFileManager.eSimFile_ = nullptr;
348 res = simFileManager.LoadBoundProfilePackage(portIndex, boundProfilePackage);
349 EXPECT_EQ(res.resultCode_, 0);
350 }
351
352 HWTEST_F(EsimFileManagerTest, ListNotifications_001, Function | MediumTest | Level2)
353 {
354 std::string expectedEid = "12345";
355 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
356 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
357 EventFwk::MatchingSkills matchingSkills;
358 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
359 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
360 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
361 std::weak_ptr<SimStateManager>(simStateManager) };
362 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
363 int32_t portIndex = 0;
364 Event events = Event::EVENT_DONOTHING;
365 EuiccNotificationList lst = simFileManager.ListNotifications(portIndex, events);
366 EXPECT_EQ(lst.euiccNotification_.empty(), true);
367 simFileManager.eSimFile_ = nullptr;
368 lst = simFileManager.ListNotifications(portIndex, events);
369 EXPECT_EQ(lst.euiccNotification_.empty(), true);
370 }
371
372 HWTEST_F(EsimFileManagerTest, RetrieveNotificationList_001, Function | MediumTest | Level2)
373 {
374 std::string expectedEid = "12345";
375 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
376 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
377 EventFwk::MatchingSkills matchingSkills;
378 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
379 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
380 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
381 std::weak_ptr<SimStateManager>(simStateManager) };
382 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
383 int32_t portIndex = 0;
384 Event events = Event::EVENT_DONOTHING;
385 EuiccNotificationList lst = simFileManager.RetrieveNotificationList(portIndex, events);
386 EXPECT_EQ(lst.euiccNotification_.empty(), true);
387 simFileManager.eSimFile_ = nullptr;
388 lst = simFileManager.RetrieveNotificationList(portIndex, events);
389 EXPECT_EQ(lst.euiccNotification_.empty(), true);
390 }
391
392 HWTEST_F(EsimFileManagerTest, RetrieveNotification_001, Function | MediumTest | Level2)
393 {
394 std::string expectedEid = "12345";
395 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
396 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
397 EventFwk::MatchingSkills matchingSkills;
398 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
399 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
400 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
401 std::weak_ptr<SimStateManager>(simStateManager) };
402 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
403 int32_t portIndex = 0;
404 int32_t seqNumber = 0;
405 EuiccNotification res = simFileManager.RetrieveNotification(portIndex, seqNumber);
406 EXPECT_EQ(res.data_, u"");
407 simFileManager.eSimFile_ = nullptr;
408 res = simFileManager.RetrieveNotification(portIndex, seqNumber);
409 EXPECT_EQ(res.data_, u"");
410 }
411
412 HWTEST_F(EsimFileManagerTest, RemoveNotificationFromList_001, Function | MediumTest | Level2)
413 {
414 std::string expectedEid = "12345";
415 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
416 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
417 EventFwk::MatchingSkills matchingSkills;
418 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
419 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
420 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
421 std::weak_ptr<SimStateManager>(simStateManager) };
422 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
423 int32_t portIndex = 0;
424 int32_t seqNumber = 0;
425 int32_t res = simFileManager.RemoveNotificationFromList(portIndex, seqNumber);
426 EXPECT_NE(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
427 simFileManager.eSimFile_ = nullptr;
428 res = simFileManager.RemoveNotificationFromList(portIndex, seqNumber);
429 EXPECT_EQ(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
430 }
431
432 HWTEST_F(EsimFileManagerTest, DeleteProfile_001, Function | MediumTest | Level2)
433 {
434 std::string expectedEid = "12345";
435 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
436 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
437 EventFwk::MatchingSkills matchingSkills;
438 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
439 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
440 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
441 std::weak_ptr<SimStateManager>(simStateManager) };
442 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
443 std::u16string iccId = u"";
444 int32_t res = simFileManager.DeleteProfile(iccId);
445 EXPECT_NE(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
446 simFileManager.eSimFile_ = nullptr;
447 res = simFileManager.DeleteProfile(iccId);
448 EXPECT_EQ(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
449 }
450
451 HWTEST_F(EsimFileManagerTest, SwitchToProfile_001, Function | MediumTest | Level2)
452 {
453 std::string expectedEid = "12345";
454 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
455 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
456 EventFwk::MatchingSkills matchingSkills;
457 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
458 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
459 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
460 std::weak_ptr<SimStateManager>(simStateManager) };
461 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
462 int32_t portIndex = 0;
463 std::u16string iccId = u"";
464 bool forceDisableProfile = false;
465 int32_t res = simFileManager.SwitchToProfile(portIndex, iccId, forceDisableProfile);
466 EXPECT_NE(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
467 simFileManager.eSimFile_ = nullptr;
468 res = simFileManager.SwitchToProfile(portIndex, iccId, forceDisableProfile);
469 EXPECT_EQ(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
470 }
471
472 HWTEST_F(EsimFileManagerTest, SetProfileNickname_001, Function | MediumTest | Level2)
473 {
474 std::string expectedEid = "12345";
475 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
476 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
477 EventFwk::MatchingSkills matchingSkills;
478 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
479 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
480 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
481 std::weak_ptr<SimStateManager>(simStateManager) };
482 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
483 std::u16string iccId = u"";
484 std::u16string nickname = u"";
485 int32_t res = simFileManager.SetProfileNickname(iccId, nickname);
486 EXPECT_NE(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
487 simFileManager.eSimFile_ = nullptr;
488 res = simFileManager.SetProfileNickname(iccId, nickname);
489 EXPECT_EQ(res, static_cast<int32_t>(ResultCode::RESULT_SGP_22_OTHER));
490 }
491
492 HWTEST_F(EsimFileManagerTest, GetEuiccInfo2_001, Function | MediumTest | Level2)
493 {
494 std::string expectedEid = "12345";
495 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
496 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
497 EventFwk::MatchingSkills matchingSkills;
498 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
499 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
500 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
501 std::weak_ptr<SimStateManager>(simStateManager) };
502 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
503 int32_t portIndex = 0;
504 EuiccInfo2 res = simFileManager.GetEuiccInfo2(portIndex);
505 EXPECT_FALSE(res.svn_.empty());
506 simFileManager.eSimFile_ = nullptr;
507 res = simFileManager.GetEuiccInfo2(portIndex);
508 EXPECT_FALSE(res.svn_.empty());
509 }
510
511 HWTEST_F(EsimFileManagerTest, AuthenticateServer_001, Function | MediumTest | Level2)
512 {
513 std::string expectedEid = "12345";
514 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
515 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
516 EventFwk::MatchingSkills matchingSkills;
517 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
518 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
519 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
520 std::weak_ptr<SimStateManager>(simStateManager) };
521 simFileManager.eSimFile_ = std::make_shared<EsimFile>(simStateManager);
522 AuthenticateConfigInfo authenticateConfigInfo;
523 ResponseEsimInnerResult res = simFileManager.AuthenticateServer(authenticateConfigInfo);
524 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
525 simFileManager.eSimFile_ = nullptr;
526 res = simFileManager.AuthenticateServer(authenticateConfigInfo);
527 EXPECT_EQ(res.resultCode_, static_cast<int32_t>(ResultCode::RESULT_OK));
528 }
529 } // namespace Telephony
530 } // namespace OHOS
531