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 "core_manager_inner.h"
22 #include "core_service.h"
23 #include "core_service_client.h"
24 #include "enum_convert.h"
25 #include "operator_config_cache.h"
26 #include "operator_file_parser.h"
27 #include "sim_manager.h"
28 #include "sim_state_type.h"
29 #include "str_convert.h"
30 #include "string_ex.h"
31 #include "tel_profile_util.h"
32 #include "telephony_ext_wrapper.h"
33 #include "tel_ril_manager.h"
34 #include "gtest/gtest.h"
35
36 namespace OHOS {
37 namespace Telephony {
38 using namespace testing::ext;
39 class EsimManagerTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
TearDownTestCase()47 void EsimManagerTest::TearDownTestCase() {}
48
SetUp()49 void EsimManagerTest::SetUp() {}
50
TearDown()51 void EsimManagerTest::TearDown() {}
52
SetUpTestCase()53 void EsimManagerTest::SetUpTestCase() {}
54
55 HWTEST_F(EsimManagerTest, GetEid, Function | MediumTest | Level1)
56 {
57 int32_t slotId = 0;
58 std::u16string eId;
59 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
60 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
61 int32_t ret = simManager->GetEid(slotId, eId);
62 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
63 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
64 simManager->simStateManager_.push_back(simStateManager);
65 simManager->simStateManager_[slotId]->Init(slotId);
66 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
67 ret = simManager->GetEid(slotId, eId);
68 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
69 EventFwk::CommonEventSubscribeInfo sp;
70 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
71 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
72 std::shared_ptr<Telephony::SimFileManager> simFileManager =
73 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
74 simManager->simFileManager_.push_back(simFileManager);
75 simManager->simFileManager_[slotId]->Init(slotId);
76 ret = simManager->GetEid(slotId, eId);
77 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
78 }
79
80 HWTEST_F(EsimManagerTest, GetEuiccProfileInfoList, Function | MediumTest | Level1)
81 {
82 int32_t slotId = 0;
83 GetEuiccProfileInfoListInnerResult result;
84 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
85 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
86 int32_t ret = simManager->GetEuiccProfileInfoList(slotId, result);
87 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
88 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
89 simManager->simStateManager_.push_back(simStateManager);
90 simManager->simStateManager_[slotId]->Init(slotId);
91 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
92 ret = simManager->GetEuiccProfileInfoList(slotId, result);
93 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
94 EventFwk::CommonEventSubscribeInfo sp;
95 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
96 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
97 std::shared_ptr<Telephony::SimFileManager> simFileManager =
98 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
99 simManager->simFileManager_.push_back(simFileManager);
100 simManager->simFileManager_[slotId]->Init(slotId);
101 ret = simManager->GetEuiccProfileInfoList(slotId, result);
102 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
103 }
104
105 HWTEST_F(EsimManagerTest, GetEuiccInfo, Function | MediumTest | Level1)
106 {
107 int32_t slotId = 0;
108 EuiccInfo eUiccInfo;
109 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
110 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
111 int32_t ret = simManager->GetEuiccInfo(slotId, eUiccInfo);
112 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
113 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
114 simManager->simStateManager_.push_back(simStateManager);
115 simManager->simStateManager_[slotId]->Init(slotId);
116 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
117 ret = simManager->GetEuiccInfo(slotId, eUiccInfo);
118 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
119 EventFwk::CommonEventSubscribeInfo sp;
120 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
121 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
122 std::shared_ptr<Telephony::SimFileManager> simFileManager =
123 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
124 simManager->simFileManager_.push_back(simFileManager);
125 simManager->simFileManager_[slotId]->Init(slotId);
126 ret = simManager->GetEuiccInfo(slotId, eUiccInfo);
127 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
128 }
129
130 HWTEST_F(EsimManagerTest, DisableProfile, Function | MediumTest | Level1)
131 {
132 int32_t slotId = 0;
133 int32_t portIndex = 0;
134 std::u16string iccId = Str8ToStr16("98760000000000543210");
135 bool refresh = true;
136 int32_t disableProfileResult;
137 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
138 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
139 int32_t ret = simManager->DisableProfile(slotId, portIndex, iccId, refresh, disableProfileResult);
140 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
141
142 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
143 simManager->simStateManager_.push_back(simStateManager);
144 simManager->simStateManager_[slotId]->Init(slotId);
145 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
146 ret = simManager->DisableProfile(slotId, portIndex, iccId, refresh, disableProfileResult);
147 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
148
149 EventFwk::CommonEventSubscribeInfo sp;
150 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
151 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
152 std::shared_ptr<Telephony::SimFileManager> simFileManager =
153 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
154 simManager->simFileManager_.push_back(simFileManager);
155 simManager->simFileManager_[slotId]->Init(slotId);
156 ret = simManager->DisableProfile(slotId, portIndex, iccId, refresh, disableProfileResult);
157 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
158 }
159
160 HWTEST_F(EsimManagerTest, GetSmdsAddress, Function | MediumTest | Level1)
161 {
162 int32_t slotId = 0;
163 int32_t portIndex = 0;
164 std::u16string smdsAddress;
165 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
166 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
167 int32_t ret = simManager->GetSmdsAddress(slotId, portIndex, smdsAddress);
168 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
169
170 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
171 simManager->simStateManager_.push_back(simStateManager);
172 simManager->simStateManager_[slotId]->Init(slotId);
173 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
174 ret = simManager->GetSmdsAddress(slotId, portIndex, smdsAddress);
175 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
176
177 EventFwk::CommonEventSubscribeInfo sp;
178 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
179 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
180 std::shared_ptr<Telephony::SimFileManager> simFileManager =
181 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
182 simManager->simFileManager_.push_back(simFileManager);
183 simManager->simFileManager_[slotId]->Init(slotId);
184 ret = simManager->GetSmdsAddress(slotId, portIndex, smdsAddress);
185 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
186 }
187
188 HWTEST_F(EsimManagerTest, GetRulesAuthTable, Function | MediumTest | Level1)
189 {
190 int32_t slotId = 0;
191 int32_t portIndex = 0;
192 EuiccRulesAuthTable eUiccRulesAuthTable;
193 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
194 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
195 int32_t ret = simManager->GetRulesAuthTable(slotId, portIndex, eUiccRulesAuthTable);
196 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
197
198 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
199 simManager->simStateManager_.push_back(simStateManager);
200 simManager->simStateManager_[slotId]->Init(slotId);
201 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
202 ret = simManager->GetRulesAuthTable(slotId, portIndex, eUiccRulesAuthTable);
203 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
204
205 EventFwk::CommonEventSubscribeInfo sp;
206 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
207 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
208 std::shared_ptr<Telephony::SimFileManager> simFileManager =
209 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
210 simManager->simFileManager_.push_back(simFileManager);
211 simManager->simFileManager_[slotId]->Init(slotId);
212 ret = simManager->GetRulesAuthTable(slotId, portIndex, eUiccRulesAuthTable);
213 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
214 }
215
216 HWTEST_F(EsimManagerTest, GetEuiccChallenge, Function | MediumTest | Level1)
217 {
218 int32_t slotId = 0;
219 int32_t portIndex = 0;
220 ResponseEsimInnerResult responseResult;
221 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
222 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
223 int32_t ret = simManager->GetEuiccChallenge(slotId, portIndex, responseResult);
224 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
225
226 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
227 simManager->simStateManager_.push_back(simStateManager);
228 simManager->simStateManager_[slotId]->Init(slotId);
229 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
230 ret = simManager->GetEuiccChallenge(slotId, portIndex, responseResult);
231 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
232
233 EventFwk::CommonEventSubscribeInfo sp;
234 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
235 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
236 std::shared_ptr<Telephony::SimFileManager> simFileManager =
237 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
238 simManager->simFileManager_.push_back(simFileManager);
239 simManager->simFileManager_[slotId]->Init(slotId);
240 ret = simManager->GetEuiccChallenge(slotId, portIndex, responseResult);
241 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
242 }
243
244 HWTEST_F(EsimManagerTest, GetDefaultSmdpAddress, Function | MediumTest | Level1)
245 {
246 int32_t slotId = 0;
247 std::u16string actualAddress;
248 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
249 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
250 int32_t ret = simManager->GetDefaultSmdpAddress(slotId, actualAddress);
251 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
252 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
253 simManager->simStateManager_.push_back(simStateManager);
254 simManager->simStateManager_[slotId]->Init(slotId);
255 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
256 ret = simManager->GetDefaultSmdpAddress(slotId, actualAddress);
257 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
258 EventFwk::CommonEventSubscribeInfo sp;
259 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
260 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
261 std::shared_ptr<Telephony::SimFileManager> simFileManager =
262 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
263 simManager->simFileManager_.push_back(simFileManager);
264 simManager->simFileManager_[slotId]->Init(slotId);
265 ret = simManager->GetDefaultSmdpAddress(slotId, actualAddress);
266 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
267 }
268
269 HWTEST_F(EsimManagerTest, CancelSession, Function | MediumTest | Level1)
270 {
271 int32_t slotId = 0;
272 std::u16string transactionId = Str8ToStr16("A1B2C3");
273 const CancelReason cancelReason = CancelReason::CANCEL_REASON_POSTPONED;
274 ResponseEsimInnerResult responseResult;
275 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
276 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
277 int32_t ret = simManager->CancelSession(slotId, transactionId, cancelReason, responseResult);
278 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
279 std::shared_ptr<Telephony::SimStateManager> simStateManager =
280 std::make_shared<SimStateManager>(telRilManager);
281 simManager->simStateManager_.push_back(simStateManager);
282 simManager->simStateManager_[slotId]->Init(slotId);
283 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
284 ret = simManager->CancelSession(slotId, transactionId, cancelReason, responseResult);
285 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
286 EventFwk::CommonEventSubscribeInfo sp;
287 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
288 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
289 std::shared_ptr<Telephony::SimFileManager> simFileManager =
290 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
291 simManager->simFileManager_.push_back(simFileManager);
292 simManager->simFileManager_[slotId]->Init(slotId);
293 ret = simManager->CancelSession(slotId, transactionId, cancelReason, responseResult);
294 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
295 }
296
297 HWTEST_F(EsimManagerTest, GetProfile, Function | MediumTest | Level1)
298 {
299 int32_t slotId = 0;
300 int32_t portIndex = 0;
301 std::u16string iccId = Str8ToStr16("5A0A89670000000000216954");
302 EuiccProfile eUiccProfile;
303 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
304 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
305 int32_t ret = simManager->GetProfile(slotId, portIndex, iccId, eUiccProfile);
306 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
307
308 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
309 simManager->simStateManager_.push_back(simStateManager);
310 simManager->simStateManager_[slotId]->Init(slotId);
311 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
312 ret = simManager->GetProfile(slotId, portIndex, iccId, eUiccProfile);
313 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
314
315 EventFwk::CommonEventSubscribeInfo sp;
316 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
317 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
318 std::shared_ptr<Telephony::SimFileManager> simFileManager =
319 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
320 simManager->simFileManager_.push_back(simFileManager);
321 simManager->simFileManager_[slotId]->Init(slotId);
322 ret = simManager->GetProfile(slotId, portIndex, iccId, eUiccProfile);
323 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
324 }
325
326 HWTEST_F(EsimManagerTest, ResetMemory, Function | MediumTest | Level1)
327 {
328 int32_t slotId = 0;
329 int32_t resetMemoryResult;
330 const ResetOption resetOption = ResetOption::DELETE_OPERATIONAL_PROFILES;
331 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
332 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
333 int32_t ret = simManager->ResetMemory(slotId, resetOption, resetMemoryResult);
334 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
335 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
336 simManager->simStateManager_.push_back(simStateManager);
337 simManager->simStateManager_[slotId]->Init(slotId);
338 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
339 ret = simManager->ResetMemory(slotId, resetOption, resetMemoryResult);
340 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
341 EventFwk::CommonEventSubscribeInfo sp;
342 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
343 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
344 std::shared_ptr<Telephony::SimFileManager> simFileManager =
345 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
346 simManager->simFileManager_.push_back(simFileManager);
347 simManager->simFileManager_[slotId]->Init(slotId);
348 ret = simManager->ResetMemory(slotId, resetOption, resetMemoryResult);
349 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
350 }
351
352 HWTEST_F(EsimManagerTest, SetDefaultSmdpAddress, Function | MediumTest | Level1)
353 {
354 int32_t slotId = 0;
355 std::u16string defaultSmdpAddress = Str8ToStr16("test.com");
356 int32_t setAddressResult;
357 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
358 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
359 int32_t ret = simManager->SetDefaultSmdpAddress(slotId, defaultSmdpAddress, setAddressResult);
360 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
361 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
362 simManager->simStateManager_.push_back(simStateManager);
363 simManager->simStateManager_[slotId]->Init(slotId);
364 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
365 ret = simManager->SetDefaultSmdpAddress(slotId, defaultSmdpAddress, setAddressResult);
366 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
367 EventFwk::CommonEventSubscribeInfo sp;
368 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
369 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
370 std::shared_ptr<Telephony::SimFileManager> simFileManager =
371 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
372 simManager->simFileManager_.push_back(simFileManager);
373 simManager->simFileManager_[slotId]->Init(slotId);
374 ret = simManager->SetDefaultSmdpAddress(slotId, defaultSmdpAddress, setAddressResult);
375 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
376 }
377
378 HWTEST_F(EsimManagerTest, IsSupported, Function | MediumTest | Level1)
379 {
380 int32_t slotId = 0;
381 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
382 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
383 EXPECT_FALSE(simManager->IsSupported(slotId));
384 }
385
386 HWTEST_F(EsimManagerTest, SendApduData, Function | MediumTest | Level1)
387 {
388 int32_t slotId = 0;
389 std::u16string aid = Str8ToStr16("aid test");
390 EsimApduData apduData;
391 ResponseEsimInnerResult responseResult;
392 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
393 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
394 int32_t ret = simManager->SendApduData(slotId, aid, apduData, responseResult);
395 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
396 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
397 simManager->simStateManager_.push_back(simStateManager);
398 simManager->simStateManager_[slotId]->Init(slotId);
399 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
400 ret = simManager->SendApduData(slotId, aid, apduData, responseResult);
401 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
402 EventFwk::CommonEventSubscribeInfo sp;
403 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
404 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
405 std::shared_ptr<Telephony::SimFileManager> simFileManager =
406 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
407 simManager->simFileManager_.push_back(simFileManager);
408 simManager->simFileManager_[slotId]->Init(slotId);
409 ret = simManager->SendApduData(slotId, aid, apduData, responseResult);
410 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
411 }
412
413 HWTEST_F(EsimManagerTest, PrepareDownload, Function | MediumTest | Level1)
414 {
415 int32_t slotId = 0;
416 DownLoadConfigInfo downLoadConfigInfo;
417 downLoadConfigInfo.portIndex_ = 0;
418 downLoadConfigInfo.hashCc_ = Str8ToStr16("4131423243332D583459355A36");
419 ResponseEsimInnerResult responseResult;
420 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
421 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
422 int32_t ret = simManager->PrepareDownload(slotId, downLoadConfigInfo, responseResult);
423 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
424 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
425 simManager->simStateManager_.push_back(simStateManager);
426 simManager->simStateManager_[slotId]->Init(slotId);
427 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
428 ret = simManager->PrepareDownload(slotId, downLoadConfigInfo, responseResult);
429 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
430 EventFwk::CommonEventSubscribeInfo sp;
431 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
432 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
433 std::shared_ptr<Telephony::SimFileManager> simFileManager =
434 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
435 simManager->simFileManager_.push_back(simFileManager);
436 simManager->simFileManager_[slotId]->Init(slotId);
437 ret = simManager->PrepareDownload(slotId, downLoadConfigInfo, responseResult);
438 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
439 }
440
441 HWTEST_F(EsimManagerTest, LoadBoundProfilePackage, Function | MediumTest | Level1)
442 {
443 int32_t slotId = 0;
444 int32_t portIndex = 0;
445 std::u16string boundProfilePackage;
446 ResponseEsimBppResult responseResult;
447 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
448 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
449 int32_t ret = simManager->LoadBoundProfilePackage(slotId, portIndex, boundProfilePackage, responseResult);
450 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
451 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
452 simManager->simStateManager_.push_back(simStateManager);
453 simManager->simStateManager_[slotId]->Init(slotId);
454 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
455 ret = simManager->LoadBoundProfilePackage(slotId, portIndex, boundProfilePackage, responseResult);
456 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
457 EventFwk::CommonEventSubscribeInfo sp;
458 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
459 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
460 std::shared_ptr<Telephony::SimFileManager> simFileManager =
461 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
462 simManager->simFileManager_.push_back(simFileManager);
463 simManager->simFileManager_[slotId]->Init(slotId);
464 ret = simManager->LoadBoundProfilePackage(slotId, portIndex, boundProfilePackage, responseResult);
465 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
466 }
467
468 HWTEST_F(EsimManagerTest, ListNotifications, Function | MediumTest | Level1)
469 {
470 int32_t slotId = 0;
471 int32_t portIndex = 0;
472 const Event events = Event::EVENT_DELETE;
473 EuiccNotificationList notificationList;
474 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
475 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
476 int32_t ret = simManager->ListNotifications(slotId, portIndex, events, notificationList);
477 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
478 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
479 simManager->simStateManager_.push_back(simStateManager);
480 simManager->simStateManager_[slotId]->Init(slotId);
481 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
482 ret = simManager->ListNotifications(slotId, portIndex, events, notificationList);
483 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
484 EventFwk::CommonEventSubscribeInfo sp;
485 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
486 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
487 std::shared_ptr<Telephony::SimFileManager> simFileManager =
488 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
489 simManager->simFileManager_.push_back(simFileManager);
490 simManager->simFileManager_[slotId]->Init(slotId);
491 ret = simManager->ListNotifications(slotId, portIndex, events, notificationList);
492 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
493 }
494
495 HWTEST_F(EsimManagerTest, RetrieveNotificationList, Function | MediumTest | Level1)
496 {
497 int32_t slotId = 0;
498 int32_t portIndex = 0;
499 const Event events = Event::EVENT_DISABLE;
500 EuiccNotificationList notificationList;
501 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
502 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
503 int32_t ret = simManager->RetrieveNotificationList(slotId, portIndex, events, notificationList);
504 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
505
506 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
507 simManager->simStateManager_.push_back(simStateManager);
508 simManager->simStateManager_[slotId]->Init(slotId);
509 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
510 ret = simManager->RetrieveNotificationList(slotId, portIndex, events, notificationList);
511 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
512
513 EventFwk::CommonEventSubscribeInfo sp;
514 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
515 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
516 std::shared_ptr<Telephony::SimFileManager> simFileManager =
517 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
518 simManager->simFileManager_.push_back(simFileManager);
519 simManager->simFileManager_[slotId]->Init(slotId);
520 ret = simManager->RetrieveNotificationList(slotId, portIndex, events, notificationList);
521 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
522 }
523
524 HWTEST_F(EsimManagerTest, RetrieveNotification, Function | MediumTest | Level1)
525 {
526 int32_t slotId = 0;
527 int32_t portIndex = 0;
528 int32_t seqNumber = 5;
529 EuiccNotification notification;
530 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
531 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
532 int32_t ret = simManager->RetrieveNotification(slotId, portIndex, seqNumber, notification);
533 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
534
535 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
536 simManager->simStateManager_.push_back(simStateManager);
537 simManager->simStateManager_[slotId]->Init(slotId);
538 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
539 ret = simManager->RetrieveNotification(slotId, portIndex, seqNumber, notification);
540 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
541
542 EventFwk::CommonEventSubscribeInfo sp;
543 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
544 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
545 std::shared_ptr<Telephony::SimFileManager> simFileManager =
546 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
547 simManager->simFileManager_.push_back(simFileManager);
548 simManager->simFileManager_[slotId]->Init(slotId);
549 ret = simManager->RetrieveNotification(slotId, portIndex, seqNumber, notification);
550 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
551 }
552
553 HWTEST_F(EsimManagerTest, RemoveNotificationFromList, Function | MediumTest | Level1)
554 {
555 int32_t slotId = 0;
556 int32_t portIndex = 0;
557 int32_t seqNumber = 5;
558 int32_t enumResult;
559 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
560 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
561 int32_t ret = simManager->RemoveNotificationFromList(slotId, portIndex, seqNumber, enumResult);
562 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
563
564 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
565 simManager->simStateManager_.push_back(simStateManager);
566 simManager->simStateManager_[slotId]->Init(slotId);
567 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
568 ret = simManager->RemoveNotificationFromList(slotId, portIndex, seqNumber, enumResult);
569 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
570
571 EventFwk::CommonEventSubscribeInfo sp;
572 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
573 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
574 std::shared_ptr<Telephony::SimFileManager> simFileManager =
575 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
576 simManager->simFileManager_.push_back(simFileManager);
577 simManager->simFileManager_[slotId]->Init(slotId);
578 ret = simManager->RemoveNotificationFromList(slotId, portIndex, seqNumber, enumResult);
579 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
580 }
581
582 HWTEST_F(EsimManagerTest, DeleteProfile, Function | MediumTest | Level1)
583 {
584 int32_t slotId = 0;
585 std::u16string iccId = Str8ToStr16("98760000000000543210");
586 int32_t deleteProfileResult;
587 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
588 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
589 int32_t ret = simManager->DeleteProfile(slotId, iccId, deleteProfileResult);
590 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
591
592 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
593 simManager->simStateManager_.push_back(simStateManager);
594 simManager->simStateManager_[slotId]->Init(slotId);
595 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
596 ret = simManager->DeleteProfile(slotId, iccId, deleteProfileResult);
597 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
598
599 EventFwk::CommonEventSubscribeInfo sp;
600 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
601 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
602 std::shared_ptr<Telephony::SimFileManager> simFileManager =
603 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
604 simManager->simFileManager_.push_back(simFileManager);
605 simManager->simFileManager_[slotId]->Init(slotId);
606 ret = simManager->DeleteProfile(slotId, iccId, deleteProfileResult);
607 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
608 }
609
610 HWTEST_F(EsimManagerTest, SwitchToProfile, Function | MediumTest | Level1)
611 {
612 int32_t slotId = 0;
613 int32_t portIndex = 1;
614 std::u16string iccId = Str8ToStr16("98760000000000543210");
615 bool forceDisableProfile = true;
616 int32_t switchProfileResult;
617 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
618 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
619 int32_t ret = simManager->SwitchToProfile(slotId, portIndex, iccId, forceDisableProfile, switchProfileResult);
620 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
621
622 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
623 simManager->simStateManager_.push_back(simStateManager);
624 simManager->simStateManager_[slotId]->Init(slotId);
625 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
626 ret = simManager->SwitchToProfile(slotId, portIndex, iccId, forceDisableProfile, switchProfileResult);
627 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
628
629 EventFwk::CommonEventSubscribeInfo sp;
630 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
631 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
632 std::shared_ptr<Telephony::SimFileManager> simFileManager =
633 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
634 simManager->simFileManager_.push_back(simFileManager);
635 simManager->simFileManager_[slotId]->Init(slotId);
636 ret = simManager->SwitchToProfile(slotId, portIndex, iccId, forceDisableProfile, switchProfileResult);
637 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
638 }
639
640 HWTEST_F(EsimManagerTest, SetProfileNickname, Function | MediumTest | Level1)
641 {
642 int32_t slotId = 0;
643 std::u16string iccId = Str8ToStr16("98760000000000543210");
644 std::u16string nickname = Str8ToStr16("nick");
645 int32_t updateResult;
646 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
647 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
648 int32_t ret = simManager->SetProfileNickname(slotId, iccId, nickname, updateResult);
649 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
650
651 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
652 simManager->simStateManager_.push_back(simStateManager);
653 simManager->simStateManager_[slotId]->Init(slotId);
654 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
655 ret = simManager->SetProfileNickname(slotId, iccId, nickname, updateResult);
656 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
657
658 EventFwk::CommonEventSubscribeInfo sp;
659 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
660 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
661 std::shared_ptr<Telephony::SimFileManager> simFileManager =
662 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
663 simManager->simFileManager_.push_back(simFileManager);
664 simManager->simFileManager_[slotId]->Init(slotId);
665 ret = simManager->SetProfileNickname(slotId, iccId, nickname, updateResult);
666 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
667 }
668
669 HWTEST_F(EsimManagerTest, GetEuiccInfo2, Function | MediumTest | Level1)
670 {
671 int32_t slotId = 0;
672 int32_t portIndex = 0;
673 EuiccInfo2 euiccInfo2;
674 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
675 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
676 int32_t ret = simManager->GetEuiccInfo2(slotId, portIndex, euiccInfo2);
677 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
678 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
679 simManager->simStateManager_.push_back(simStateManager);
680 simManager->simStateManager_[slotId]->Init(slotId);
681 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
682 ret = simManager->GetEuiccInfo2(slotId, portIndex, euiccInfo2);
683 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
684 EventFwk::CommonEventSubscribeInfo sp;
685 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
686 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
687 std::shared_ptr<Telephony::SimFileManager> simFileManager =
688 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
689 simManager->simFileManager_.push_back(simFileManager);
690 simManager->simFileManager_[slotId]->Init(slotId);
691 ret = simManager->GetEuiccInfo2(slotId, portIndex, euiccInfo2);
692 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
693 }
694
695 HWTEST_F(EsimManagerTest, AuthenticateServer, Function | MediumTest | Level1)
696 {
697 int32_t slotId = 0;
698 AuthenticateConfigInfo authenticateConfigInfo;
699 authenticateConfigInfo.matchingId_ = Str8ToStr16("4131423243332D583459355A36");
700 ResponseEsimInnerResult responseResult;
701 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
702 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
703 int32_t ret = simManager->AuthenticateServer(slotId, authenticateConfigInfo, responseResult);
704 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
705 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
706 simManager->simStateManager_.push_back(simStateManager);
707 simManager->simStateManager_[slotId]->Init(slotId);
708 simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = -1;
709 ret = simManager->AuthenticateServer(slotId, authenticateConfigInfo, responseResult);
710 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
711 EventFwk::CommonEventSubscribeInfo sp;
712 std::weak_ptr<Telephony::ITelRilManager> iTelRilManager = telRilManager;
713 std::weak_ptr<Telephony::SimStateManager> state = simStateManager;
714 std::shared_ptr<Telephony::SimFileManager> simFileManager =
715 std::make_shared<SimFileManager>(sp, iTelRilManager, state);
716 simManager->simFileManager_.push_back(simFileManager);
717 simManager->simFileManager_[slotId]->Init(slotId);
718 ret = simManager->AuthenticateServer(slotId, authenticateConfigInfo, responseResult);
719 EXPECT_EQ(ret, TELEPHONY_ERR_SUCCESS);
720 }
721 } // namespace Telephony
722 } // namespace OHOS
723