1 /*
2 * Copyright (C) 2021-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
16 #define private public
17 #define protected public
18 #include "state_registry_test.h"
19
20 #include "core_service_client.h"
21 #include "sim_state_type.h"
22 #include "telephony_ext_wrapper.h"
23 #include "telephony_log_wrapper.h"
24 #include "telephony_observer_client.h"
25 #include "telephony_observer_proxy.h"
26 #include "telephony_state_manager.h"
27 #include "telephony_state_registry_client.h"
28 #include "telephony_state_registry_service.h"
29
30 namespace OHOS {
31 namespace Telephony {
32 using namespace testing::ext;
33 sptr<StateRegistryObserver> StateRegistryTest::telephonyObserver0_ = nullptr;
34 sptr<StateRegistryObserver> StateRegistryTest::telephonyObserver1_ = nullptr;
35 static constexpr int32_t SIM_SLOT_ID_1 = DEFAULT_SIM_SLOT_ID + 1;
36 static constexpr int32_t CALL_STATUS_ACTIVE = 0;
37 static constexpr int32_t SINGLE_MODE_SIM_CARD = 10;
38 static constexpr int32_t SIM_STATE_NOT_PRESENT = 1;
39 static constexpr int32_t SIM_PIN = 1;
40 static constexpr int32_t DATA_STATE_CONNECTING = 1;
41 static constexpr int32_t NETWORK_TYPE_GSM = 1;
42 static constexpr int32_t DATA_FLOW_TYPE_DOWN = 1;
43
SetUpTestCase(void)44 void StateRegistryTest::SetUpTestCase(void)
45 {
46 ASSERT_TRUE(CoreServiceClient::GetInstance().GetProxy() != nullptr);
47 InitTelephonyObserver();
48 }
49
TearDownTestCase(void)50 void StateRegistryTest::TearDownTestCase(void)
51 {
52 DisableTelephonyObserver();
53 }
54
InitTelephonyObserver()55 void StateRegistryTest::InitTelephonyObserver()
56 {
57 TELEPHONY_LOGI("Init telephony observer");
58 AccessToken token;
59 if (!telephonyObserver0_) {
60 telephonyObserver0_ = std::make_unique<StateRegistryObserver>().release();
61 }
62 auto res =
63 Telephony::TelephonyObserverClient::GetInstance().AddStateObserver(telephonyObserver0_, DEFAULT_SIM_SLOT_ID,
64 Telephony::TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE |
65 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE |
66 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO |
67 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS |
68 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE |
69 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE |
70 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW |
71 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR |
72 Telephony::TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR,
73 true);
74 TELEPHONY_LOGI("StateRegistryTest init telephony observer0 ret:%{public}d", res);
75 ASSERT_TRUE(res == TELEPHONY_SUCCESS);
76 if (!telephonyObserver1_) {
77 telephonyObserver1_ = std::make_unique<StateRegistryObserver>().release();
78 }
79 res = Telephony::TelephonyObserverClient::GetInstance().AddStateObserver(telephonyObserver1_, SIM_SLOT_ID_1,
80 Telephony::TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE |
81 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE |
82 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO |
83 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS |
84 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE |
85 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE |
86 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW |
87 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR |
88 Telephony::TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR,
89 true);
90 TELEPHONY_LOGI("StateRegistryTest init telephony observer1 ret:%{public}d", res);
91 ASSERT_TRUE(res == TELEPHONY_SUCCESS);
92 }
93
DisableTelephonyObserver()94 void StateRegistryTest::DisableTelephonyObserver()
95 {
96 TELEPHONY_LOGI("Disable telephony observer");
97 ASSERT_TRUE(telephonyObserver0_ != nullptr);
98 Telephony::TelephonyObserverClient::GetInstance().RemoveStateObserver(
99 DEFAULT_SIM_SLOT_ID, Telephony::TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE |
100 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE |
101 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO |
102 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS |
103 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE |
104 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE |
105 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW);
106 telephonyObserver0_ = nullptr;
107 ASSERT_TRUE(telephonyObserver1_ != nullptr);
108 Telephony::TelephonyObserverClient::GetInstance().RemoveStateObserver(
109 SIM_SLOT_ID_1, Telephony::TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE |
110 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE |
111 Telephony::TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO |
112 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS |
113 Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE |
114 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE |
115 Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW);
116 telephonyObserver1_ = nullptr;
117 }
118
SetUp(void)119 void StateRegistryTest::SetUp(void)
120 {
121 // step 3: input testcase setup step
122 }
123
TearDown(void)124 void StateRegistryTest::TearDown(void)
125 {
126 // step 3: input testcase teardown step
127 }
128
HasSimCard(int32_t slotId)129 bool StateRegistryTest::HasSimCard(int32_t slotId)
130 {
131 bool hasSimCard = false;
132 CoreServiceClient::GetInstance().HasSimCard(slotId, hasSimCard);
133 return hasSimCard;
134 }
135
IsSuccess(int32_t ret)136 bool StateRegistryTest::IsSuccess(int32_t ret)
137 {
138 TELEPHONY_LOGI("ret = %{public}d, TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST = %{public}d",
139 ret, TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST);
140 if (ret == TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST || ret == TELEPHONY_ERR_SUCCESS) {
141 return true;
142 }
143 return false;
144 }
145
UpdateCallState(int32_t slotId)146 void StateRegistryTest::UpdateCallState(int32_t slotId)
147 {
148 AccessToken token;
149 int32_t callState = 16;
150 std::string phoneNumber("137xxxxxxxx");
151 std::u16string number = Str8ToStr16(phoneNumber);
152 int32_t ret =
153 DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateCallState(callState, number);
154 TELEPHONY_LOGI("StateRegistryTest::UpdateCallState ret = %{public}d", ret);
155 EXPECT_TRUE(IsSuccess(ret));
156 }
157
UpdateCallStateForSlotId(int32_t slotId)158 void StateRegistryTest::UpdateCallStateForSlotId(int32_t slotId)
159 {
160 AccessToken token;
161 int32_t callState = 16;
162 std::string phoneNumber("137xxxxxxxx");
163 std::u16string number = Str8ToStr16(phoneNumber);
164 int32_t ret = DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateCallStateForSlotId(
165 slotId, callState, number);
166 TELEPHONY_LOGI("StateRegistryTest::UpdateCallStateForSlotId ret = %{public}d", ret);
167 EXPECT_TRUE(IsSuccess(ret));
168 }
169
UpdateSignalInfo(int32_t slotId)170 void StateRegistryTest::UpdateSignalInfo(int32_t slotId)
171 {
172 AccessToken token;
173 std::vector<sptr<SignalInformation>> vec;
174 std::unique_ptr<SignalInformation> signal = std::make_unique<GsmSignalInformation>();
175 ASSERT_TRUE(signal != nullptr);
176 vec.push_back(signal.release());
177 int32_t ret = DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateSignalInfo(slotId, vec);
178 TELEPHONY_LOGI("StateRegistryTest::UpdateSignalInfo result = %{public}d", ret);
179 EXPECT_TRUE(IsSuccess(ret));
180 }
181
UpdateCellularDataConnectState(int32_t slotId)182 void StateRegistryTest::UpdateCellularDataConnectState(int32_t slotId)
183 {
184 AccessToken token;
185 int32_t dataState = 1;
186 int32_t networkState = 1;
187 int32_t ret = DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateCellularDataConnectState(
188 slotId, dataState, networkState);
189 TELEPHONY_LOGI("StateRegistryTest::UpdateCellularDataConnectState ret = %{public}d", ret);
190 EXPECT_TRUE(IsSuccess(ret));
191 }
192
UpdateCellularDataFlow(int32_t slotId)193 void StateRegistryTest::UpdateCellularDataFlow(int32_t slotId)
194 {
195 AccessToken token;
196 int32_t dataFlowType = 0;
197 int32_t ret =
198 DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateCellularDataFlow(slotId, dataFlowType);
199 TELEPHONY_LOGI("StateRegistryTest::UpdateCellularDataFlow ret = %{public}d", ret);
200 EXPECT_TRUE(IsSuccess(ret));
201 }
202
UpdateSimState(int32_t slotId)203 void StateRegistryTest::UpdateSimState(int32_t slotId)
204 {
205 AccessToken token;
206 CardType type = CardType::UNKNOWN_CARD;
207 SimState state = SimState::SIM_STATE_UNKNOWN;
208 LockReason reason = LockReason::SIM_NONE;
209 int32_t ret =
210 DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateSimState(slotId, type, state, reason);
211 TELEPHONY_LOGI("StateRegistryTest::UpdateSimState ret = %{public}d", ret);
212 EXPECT_TRUE(IsSuccess(ret));
213 }
214
UpdateNetworkState(int32_t slotId)215 void StateRegistryTest::UpdateNetworkState(int32_t slotId)
216 {
217 AccessToken token;
218 std::unique_ptr<NetworkState> networkState = std::make_unique<NetworkState>();
219 ASSERT_TRUE(networkState != nullptr);
220 int32_t ret = DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateNetworkState(
221 slotId, networkState.release());
222 TELEPHONY_LOGI("StateRegistryTest::UpdateNetworkState ret = %{public}d", ret);
223 EXPECT_TRUE(IsSuccess(ret));
224 }
225
UpdateCfuIndicator(int32_t slotId)226 void StateRegistryTest::UpdateCfuIndicator(int32_t slotId)
227 {
228 AccessToken token;
229 bool cfuResult = true;
230 int32_t ret = DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateCfuIndicator(
231 slotId, cfuResult);
232 TELEPHONY_LOGI("StateRegistryTest::UpdateCfuIndicator ret = %{public}d", ret);
233 EXPECT_TRUE(IsSuccess(ret));
234 }
235
UpdateVoiceMailMsgIndicator(int32_t slotId)236 void StateRegistryTest::UpdateVoiceMailMsgIndicator(int32_t slotId)
237 {
238 AccessToken token;
239 bool voiceMailMsgResult = true;
240 int32_t ret = DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateVoiceMailMsgIndicator(
241 slotId, voiceMailMsgResult);
242 TELEPHONY_LOGI("StateRegistryTest::UpdateVoiceMailMsgIndicator ret = %{public}d", ret);
243 EXPECT_TRUE(IsSuccess(ret));
244 }
245
UpdateIccAccount()246 void StateRegistryTest::UpdateIccAccount()
247 {
248 AccessToken token;
249 int32_t ret = DelayedRefSingleton<TelephonyStateRegistryClient>::GetInstance().UpdateIccAccount();
250 TELEPHONY_LOGI("StateRegistryTest::UpdateIccAccount ret = %{public}d", ret);
251 EXPECT_TRUE(IsSuccess(ret));
252 }
253
254 #ifndef TEL_TEST_UNSUPPORT
255 /**
256 * @tc.number StateRegistry_001
257 * @tc.name Get System Services
258 * @tc.desc Function test
259 */
260 HWTEST_F(StateRegistryTest, StateRegistry_001, Function | MediumTest | Level0)
261 {
262 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
263 ASSERT_TRUE(systemAbilityMgr != nullptr);
264 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID);
265 ASSERT_TRUE(remote != nullptr);
266 auto stateRegistryService = iface_cast<ITelephonyStateNotify>(remote);
267 ASSERT_TRUE(stateRegistryService != nullptr);
268 TELEPHONY_LOGI("HWTEST_F StateRegistry_001");
269 }
270
271 /**
272 * @tc.number UpdateCallState_001
273 * @tc.name update call state
274 * @tc.desc Function test
275 */
276 HWTEST_F(StateRegistryTest, UpdateCallState_001, Function | MediumTest | Level1)
277 {
278 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
279 TELEPHONY_LOGI("no sim card!");
280 }
281 UpdateCallState(DEFAULT_SIM_SLOT_ID);
282 }
283
284 /**
285 * @tc.number UpdateCallState_002
286 * @tc.name update call state
287 * @tc.desc Function test
288 */
289 HWTEST_F(StateRegistryTest, UpdateCallState_002, Function | MediumTest | Level1)
290 {
291 if (!StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
292 TELEPHONY_LOGI("no sim card!");
293 }
294 UpdateCallState(SIM_SLOT_ID_1);
295 }
296
297 /**
298 * @tc.number UpdateCallStateForSlotId_001
299 * @tc.name update call state by slotId
300 * @tc.desc Function test
301 */
302 HWTEST_F(StateRegistryTest, UpdateCallStateForSlotId_001, Function | MediumTest | Level1)
303 {
304 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
305 TELEPHONY_LOGI("no sim card!");
306 }
307 UpdateCallStateForSlotId(DEFAULT_SIM_SLOT_ID);
308 }
309
310 /**
311 * @tc.number UpdateCallStateForSlotId_002
312 * @tc.name update call state by slotId
313 * @tc.desc Function test
314 */
315 HWTEST_F(StateRegistryTest, UpdateCallStateForSlotId_002, Function | MediumTest | Level1)
316 {
317 if (StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
318 TELEPHONY_LOGI("no sim card!");
319 UpdateCallStateForSlotId(SIM_SLOT_ID_1);
320 }
321 }
322
323 /**
324 * @tc.number UpdateSignalInfo_001
325 * @tc.name update signal info
326 * @tc.desc Function test
327 */
328 HWTEST_F(StateRegistryTest, UpdateSignalInfo_001, Function | MediumTest | Level1)
329 {
330 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
331 TELEPHONY_LOGI("no sim card!");
332 }
333 UpdateSignalInfo(DEFAULT_SIM_SLOT_ID);
334 }
335
336 /**
337 * @tc.number UpdateSignalInfo_002
338 * @tc.name update signal info
339 * @tc.desc Function test
340 */
341 HWTEST_F(StateRegistryTest, UpdateSignalInfo_002, Function | MediumTest | Level1)
342 {
343 if (!StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
344 TELEPHONY_LOGI("no sim card!");
345 }
346 UpdateSignalInfo(SIM_SLOT_ID_1);
347 }
348
349 /**
350 * @tc.number UpdateCellularDataConnectState_001
351 * @tc.name update cellular data connect state
352 * @tc.desc Function test
353 */
354 HWTEST_F(StateRegistryTest, UpdateCellularDataConnectState_001, Function | MediumTest | Level1)
355 {
356 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
357 TELEPHONY_LOGI("no sim card!");
358 }
359 UpdateCellularDataConnectState(DEFAULT_SIM_SLOT_ID);
360 }
361
362 /**
363 * @tc.number UpdateCellularDataConnectState_002
364 * @tc.name update cellular data connect state
365 * @tc.desc Function test
366 */
367 HWTEST_F(StateRegistryTest, UpdateCellularDataConnectState_002, Function | MediumTest | Level1)
368 {
369 if (StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
370 TELEPHONY_LOGI("no sim card!");
371 UpdateCellularDataConnectState(SIM_SLOT_ID_1);
372 }
373 }
374
375 /**
376 * @tc.number UpdateCellularDataFlow_001
377 * @tc.name update cellular flow data
378 * @tc.desc Function test
379 */
380 HWTEST_F(StateRegistryTest, UpdateCellularDataFlow_001, Function | MediumTest | Level1)
381 {
382 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
383 TELEPHONY_LOGI("no sim card!");
384 }
385 UpdateCellularDataFlow(DEFAULT_SIM_SLOT_ID);
386 }
387
388 /**
389 * @tc.number UpdateCellularDataFlow_002
390 * @tc.name update cellular flow data
391 * @tc.desc Function test
392 */
393 HWTEST_F(StateRegistryTest, UpdateCellularDataFlow_002, Function | MediumTest | Level1)
394 {
395 if (StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
396 TELEPHONY_LOGI("no sim card!");
397 UpdateCellularDataFlow(SIM_SLOT_ID_1);
398 }
399 }
400
401 /**
402 * @tc.number UpdateSimState_001
403 * @tc.name update sim state
404 * @tc.desc Function test
405 */
406 HWTEST_F(StateRegistryTest, UpdateSimState_001, Function | MediumTest | Level1)
407 {
408 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
409 TELEPHONY_LOGI("no sim card!");
410 }
411 UpdateSimState(DEFAULT_SIM_SLOT_ID);
412 }
413
414 /**
415 * @tc.number UpdateSimState_002
416 * @tc.name update sim state
417 * @tc.desc Function test
418 */
419 HWTEST_F(StateRegistryTest, UpdateSimState_002, Function | MediumTest | Level1)
420 {
421 if (StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
422 TELEPHONY_LOGI("no sim card!");
423 UpdateSimState(SIM_SLOT_ID_1);
424 }
425 }
426
427 /**
428 * @tc.number UpdateNetworkState_001
429 * @tc.name update network state
430 * @tc.desc Function test
431 */
432 HWTEST_F(StateRegistryTest, UpdateNetworkState_001, Function | MediumTest | Level1)
433 {
434 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
435 TELEPHONY_LOGI("no sim card!");
436 }
437 UpdateNetworkState(DEFAULT_SIM_SLOT_ID);
438 }
439
440 /**
441 * @tc.number UpdateNetworkState_002
442 * @tc.name update network state
443 * @tc.desc Function test
444 */
445 HWTEST_F(StateRegistryTest, UpdateNetworkState_002, Function | MediumTest | Level1)
446 {
447 if (StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
448 TELEPHONY_LOGI("no sim card!");
449 UpdateNetworkState(SIM_SLOT_ID_1);
450 }
451 }
452
453 /**
454 * @tc.number UpdateCfuIndicator_001
455 * @tc.name update the result of call forwarding
456 * @tc.desc Function test
457 */
458 HWTEST_F(StateRegistryTest, UpdateCfuIndicator_001, Function | MediumTest | Level1)
459 {
460 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
461 TELEPHONY_LOGI("no sim card!");
462 }
463 UpdateCfuIndicator(DEFAULT_SIM_SLOT_ID);
464 }
465
466 /**
467 * @tc.number UpdateCfuIndicator_002
468 * @tc.name update the result of call forwarding
469 * @tc.desc Function test
470 */
471 HWTEST_F(StateRegistryTest, UpdateCfuIndicator_002, Function | MediumTest | Level1)
472 {
473 if (StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
474 TELEPHONY_LOGI("no sim card!");
475 UpdateCfuIndicator(SIM_SLOT_ID_1);
476 }
477 }
478
479 /**
480 * @tc.number UpdateVoiceMailMsgIndicator_001
481 * @tc.name update voice mail message indicator
482 * @tc.desc Function test
483 */
484 HWTEST_F(StateRegistryTest, UpdateVoiceMailMsgIndicator_001, Function | MediumTest | Level1)
485 {
486 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
487 TELEPHONY_LOGI("no sim card!");
488 }
489 UpdateVoiceMailMsgIndicator(DEFAULT_SIM_SLOT_ID);
490 }
491
492 /**
493 * @tc.number UpdateVoiceMailMsgIndicator_002
494 * @tc.name update voice mail message indicator
495 * @tc.desc Function test
496 */
497 HWTEST_F(StateRegistryTest, UpdateVoiceMailMsgIndicator_002, Function | MediumTest | Level1)
498 {
499 if (StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
500 TELEPHONY_LOGI("no sim card!");
501 UpdateVoiceMailMsgIndicator(SIM_SLOT_ID_1);
502 }
503 }
504
505 /**
506 * @tc.number UpdateIccAccount_001
507 * @tc.name Update Icc Account
508 * @tc.desc Function test
509 */
510 HWTEST_F(StateRegistryTest, UpdateIccAccount_001, Function | MediumTest | Level1)
511 {
512 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
513 TELEPHONY_LOGI("no sim card!");
514 }
515 UpdateIccAccount();
516 }
517
518 /**
519 * @tc.number UpdateIccAccount_002
520 * @tc.name UpdateIccAccount
521 * @tc.desc Function test
522 */
523 HWTEST_F(StateRegistryTest, UpdateIccAccount_002, Function | MediumTest | Level1)
524 {
525 if (!StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
526 TELEPHONY_LOGI("no sim card!");
527 }
528 UpdateIccAccount();
529 }
530
531 /**
532 * @tc.number TelephonyStateManagerTest_001
533 * @tc.name telephony state manager add/remove state observer test
534 * @tc.desc Function test
535 */
536 HWTEST_F(StateRegistryTest, TelephonyStateManagerTest_001, Function | MediumTest | Level1)
537 {
538 TELEPHONY_LOGI("TelephonyStateManagerTest_001 start!");
539 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
540 TELEPHONY_LOGI("no sim card!");
541 }
542 TelephonyStateManager::AddStateObserver(
543 telephonyObserver0_, DEFAULT_SIM_SLOT_ID, TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE, true);
544 wptr<IRemoteObject> wptrDeath = nullptr;
545 int32_t ret = TelephonyStateManager::RemoveStateObserver(
546 DEFAULT_SIM_SLOT_ID, Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE);
547 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
548 }
549
550 /**
551 * @tc.number TelephonyStateManagerTest_002
552 * @tc.name telephony state manager add/remove state observer test
553 * @tc.desc Function test
554 */
555 HWTEST_F(StateRegistryTest, TelephonyStateManagerTest_002, Function | MediumTest | Level1)
556 {
557 TELEPHONY_LOGI("TelephonyStateManagerTest_002 start!");
558 if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
559 TELEPHONY_LOGI("no sim card!");
560 }
561 TelephonyStateManager::AddStateObserver(
562 telephonyObserver0_, DEFAULT_SIM_SLOT_ID, TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE, true);
563 wptr<IRemoteObject> wptrDeath = nullptr;
564 int32_t ret = TelephonyStateManager::RemoveStateObserver(
565 DEFAULT_SIM_SLOT_ID, Telephony::TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE);
566 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
567 }
568
569 /**
570 * @tc.number TelephonyObserverTest_001
571 * @tc.name telephony observer test
572 * @tc.desc Function test
573 */
574 HWTEST_F(StateRegistryTest, TelephonyObserverTest_001, Function | MediumTest | Level1)
575 {
576 TELEPHONY_LOGI("TelephonyObserverTest_001 start!");
577 MessageParcel dataParcel;
578 MessageParcel reply;
579 MessageOption option;
580 option.SetFlags(MessageOption::TF_ASYNC);
581 std::u16string testStr = u"test";
582 ASSERT_TRUE(dataParcel.WriteInterfaceToken(testStr));
583
584 int32_t ret = telephonyObserver.OnRemoteRequest(
585 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CALL_STATE_UPDATED), dataParcel, reply,
586 option);
587 EXPECT_EQ(TELEPHONY_ERR_DESCRIPTOR_MISMATCH, ret);
588 }
589
590 /**
591 * @tc.number TelephonyObserverTest_002
592 * @tc.name telephony observer test
593 * @tc.desc Function test
594 */
595 HWTEST_F(StateRegistryTest, TelephonyObserverTest_002, Function | MediumTest | Level1)
596 {
597 TELEPHONY_LOGI("TelephonyObserverTest_002 start!");
598 MessageParcel dataParcel;
599 MessageParcel reply;
600 MessageOption option;
601 std::u16string phoneNumber = u"123456";
602 option.SetFlags(MessageOption::TF_ASYNC);
603
604 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
605 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
606 dataParcel.WriteInt32(CALL_STATUS_ACTIVE);
607 dataParcel.WriteString16(phoneNumber);
608 int32_t ret = telephonyObserver.OnRemoteRequest(
609 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CALL_STATE_UPDATED), dataParcel, reply,
610 option);
611 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
612 }
613
614 /**
615 * @tc.number TelephonyObserverTest_003
616 * @tc.name telephony observer test
617 * @tc.desc Function test
618 */
619 HWTEST_F(StateRegistryTest, TelephonyObserverTest_003, Function | MediumTest | Level1)
620 {
621 TELEPHONY_LOGI("TelephonyObserverTest_003 start!");
622 MessageOption option;
623 MessageParcel dataParcel;
624 MessageParcel reply;
625 option.SetFlags(MessageOption::TF_ASYNC);
626
627 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
628 std::vector<sptr<SignalInformation>> vec;
629 std::unique_ptr<SignalInformation> gsmSignal = std::make_unique<GsmSignalInformation>();
630 ASSERT_TRUE(gsmSignal != nullptr);
631 vec.push_back(gsmSignal.release());
632 std::unique_ptr<WcdmaSignalInformation> wcdmaSignal = std::make_unique<WcdmaSignalInformation>();
633 ASSERT_TRUE(wcdmaSignal != nullptr);
634 vec.push_back(wcdmaSignal.release());
635 std::unique_ptr<TdScdmaSignalInformation> tdScdmaSignal = std::make_unique<TdScdmaSignalInformation>();
636 ASSERT_TRUE(tdScdmaSignal != nullptr);
637 vec.push_back(tdScdmaSignal.release());
638 std::unique_ptr<CdmaSignalInformation> cdmaSignal = std::make_unique<CdmaSignalInformation>();
639 ASSERT_TRUE(cdmaSignal != nullptr);
640 vec.push_back(cdmaSignal.release());
641 std::unique_ptr<LteSignalInformation> lteSignal = std::make_unique<LteSignalInformation>();
642 ASSERT_TRUE(lteSignal != nullptr);
643 vec.push_back(lteSignal.release());
644 int32_t size = static_cast<int32_t>(vec.size());
645 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
646 dataParcel.WriteInt32(size);
647 for (const auto &v : vec) {
648 v->Marshalling(dataParcel);
649 }
650 int32_t ret = telephonyObserver.OnRemoteRequest(
651 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_SIGNAL_INFO_UPDATED), dataParcel, reply,
652 option);
653 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
654 }
655
656 /**
657 * @tc.number TelephonyObserverTest_004
658 * @tc.name telephony observer test
659 * @tc.desc Function test
660 */
661 HWTEST_F(StateRegistryTest, TelephonyObserverTest_004, Function | MediumTest | Level1)
662 {
663 TELEPHONY_LOGI("TelephonyObserverTest_004 start!");
664 MessageOption option;
665 MessageParcel dataParcel;
666 MessageParcel reply;
667 option.SetFlags(MessageOption::TF_ASYNC);
668
669 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
670 std::vector<sptr<CellInformation>> vec;
671 std::unique_ptr<GsmCellInformation> gsmCell = std::make_unique<GsmCellInformation>();
672 ASSERT_TRUE(gsmCell != nullptr);
673 vec.push_back(gsmCell.release());
674 std::unique_ptr<LteCellInformation> lteCell = std::make_unique<LteCellInformation>();
675 ASSERT_TRUE(lteCell != nullptr);
676 vec.push_back(lteCell.release());
677 std::unique_ptr<WcdmaCellInformation> wcdmaCell = std::make_unique<WcdmaCellInformation>();
678 ASSERT_TRUE(wcdmaCell != nullptr);
679 vec.push_back(wcdmaCell.release());
680 std::unique_ptr<NrCellInformation> nrCell = std::make_unique<NrCellInformation>();
681 ASSERT_TRUE(nrCell != nullptr);
682 vec.push_back(nrCell.release());
683 int32_t size = static_cast<int32_t>(vec.size());
684 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
685
686 ASSERT_TRUE(dataParcel.WriteInt32(size));
687 for (const auto &v : vec) {
688 v->Marshalling(dataParcel);
689 }
690 int32_t ret = telephonyObserver.OnRemoteRequest(
691 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CELL_INFO_UPDATED), dataParcel, reply,
692 option);
693 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
694 }
695
696 /**
697 * @tc.number TelephonyObserverTest_005
698 * @tc.name telephony observer test
699 * @tc.desc Function test
700 */
701 HWTEST_F(StateRegistryTest, TelephonyObserverTest_005, Function | MediumTest | Level1)
702 {
703 TELEPHONY_LOGI("TelephonyObserverTest_005 start!");
704 MessageOption option;
705 MessageParcel dataParcel;
706 MessageParcel reply;
707 option.SetFlags(MessageOption::TF_ASYNC);
708
709 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
710 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
711 std::unique_ptr<NetworkState> networkState = std::make_unique<NetworkState>();
712 ASSERT_TRUE(networkState != nullptr);
713 (networkState.release())->Marshalling(dataParcel);
714 int32_t ret = telephonyObserver.OnRemoteRequest(
715 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_NETWORK_STATE_UPDATED), dataParcel, reply,
716 option);
717 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
718 }
719
720 /**
721 * @tc.number TelephonyObserverTest_006
722 * @tc.name telephony observer test
723 * @tc.desc Function test
724 */
725 HWTEST_F(StateRegistryTest, TelephonyObserverTest_006, Function | MediumTest | Level1)
726 {
727 TELEPHONY_LOGI("TelephonyObserverTest_006 start!");
728 MessageOption option;
729 MessageParcel dataParcel;
730 MessageParcel reply;
731 option.SetFlags(MessageOption::TF_ASYNC);
732
733 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
734 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
735 dataParcel.WriteInt32(SINGLE_MODE_SIM_CARD);
736 dataParcel.WriteInt32(SIM_STATE_NOT_PRESENT);
737 dataParcel.WriteInt32(SIM_PIN);
738 int32_t ret = telephonyObserver.OnRemoteRequest(
739 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_SIM_STATE_UPDATED), dataParcel, reply,
740 option);
741 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
742 }
743
744 /**
745 * @tc.number TelephonyObserverTest_007
746 * @tc.name telephony observer test
747 * @tc.desc Function test
748 */
749 HWTEST_F(StateRegistryTest, TelephonyObserverTest_007, Function | MediumTest | Level1)
750 {
751 TELEPHONY_LOGI("TelephonyObserverTest_007 start!");
752 MessageOption option;
753 MessageParcel dataParcel;
754 MessageParcel reply;
755 option.SetFlags(MessageOption::TF_ASYNC);
756
757 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
758 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
759 dataParcel.WriteInt32(DATA_STATE_CONNECTING);
760 dataParcel.WriteInt32(NETWORK_TYPE_GSM);
761 int32_t ret = telephonyObserver.OnRemoteRequest(
762 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CELLULAR_DATA_CONNECT_STATE_UPDATED),
763 dataParcel, reply, option);
764 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
765 }
766
767 /**
768 * @tc.number TelephonyObserverTest_008
769 * @tc.name telephony observer test
770 * @tc.desc Function test
771 */
772 HWTEST_F(StateRegistryTest, TelephonyObserverTest_008, Function | MediumTest | Level1)
773 {
774 TELEPHONY_LOGI("TelephonyObserverTest_008 start!");
775 MessageOption option;
776 MessageParcel dataParcel;
777 MessageParcel reply;
778 option.SetFlags(MessageOption::TF_ASYNC);
779
780 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
781 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
782 dataParcel.WriteInt32(DATA_FLOW_TYPE_DOWN);
783 int32_t ret = telephonyObserver.OnRemoteRequest(
784 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CELLULAR_DATA_FLOW_UPDATED), dataParcel,
785 reply, option);
786 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
787 }
788
789 /**
790 * @tc.number TelephonyObserverTest_009
791 * @tc.name telephony observer test
792 * @tc.desc Function test
793 */
794 HWTEST_F(StateRegistryTest, TelephonyObserverTest_009, Function | MediumTest | Level1)
795 {
796 TELEPHONY_LOGI("TelephonyObserverTest_009 start!");
797 MessageOption option;
798 MessageParcel dataParcel;
799 MessageParcel reply;
800 option.SetFlags(MessageOption::TF_ASYNC);
801
802 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
803 uint32_t testId = 123;
804 int32_t ret = telephonyObserver.OnRemoteRequest(testId, dataParcel, reply, option);
805 EXPECT_NE(TELEPHONY_ERR_SUCCESS, ret);
806 }
807
808 /**
809 * @tc.number TelephonyObserverTest_010
810 * @tc.name telephony observer test
811 * @tc.desc Function test
812 */
813 HWTEST_F(StateRegistryTest, TelephonyObserverTest_010, Function | MediumTest | Level1)
814 {
815 int32_t signalSize = 5;
816 int32_t cellInfoMaxSize = 11;
817 int32_t callState = 16;
818 std::u16string number = u"137xxxxxxxx";
819 std::unique_ptr<Telephony::TelephonyObserverClient> telephonyObserverClient =
820 std::make_unique<Telephony::TelephonyObserverClient>();
821 telephonyObserverClient->OnRemoteDied(nullptr);
822 telephonyObserverClient->proxy_ = nullptr;
823 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
824 sptr<IRemoteObject> obj = sam->CheckSystemAbility(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID);
825 telephonyObserverClient->OnRemoteDied(obj);
826 telephonyObserverClient->proxy_ = iface_cast<ITelephonyStateNotify>(obj);
827 telephonyObserverClient->OnRemoteDied(obj);
828 std::shared_ptr<OHOS::Telephony::TelephonyObserverProxy> telephonyObserverProxy =
829 std::make_shared<OHOS::Telephony::TelephonyObserverProxy>(obj);
830 telephonyObserverProxy->OnCallStateUpdated(DEFAULT_SIM_SLOT_ID, callState, number);
831 std::vector<sptr<SignalInformation>> signalInformations;
832 telephonyObserverProxy->OnSignalInfoUpdated(DEFAULT_SIM_SLOT_ID, signalInformations);
833 for (int32_t i = 0; i < signalSize; i++) {
834 sptr<SignalInformation> signalInformation = sptr<SignalInformation>();
835 signalInformations.push_back(signalInformation);
836 }
837 telephonyObserverProxy->OnSignalInfoUpdated(DEFAULT_SIM_SLOT_ID, signalInformations);
838 std::vector<sptr<CellInformation>> cellInformations;
839 telephonyObserverProxy->OnCellInfoUpdated(DEFAULT_SIM_SLOT_ID, cellInformations);
840 for (int32_t i = 0; i < cellInfoMaxSize; i++) {
841 sptr<CellInformation> cellInfo = sptr<CellInformation>();
842 cellInformations.push_back(cellInfo);
843 }
844 telephonyObserverProxy->OnCellInfoUpdated(DEFAULT_SIM_SLOT_ID, cellInformations);
845 EXPECT_TRUE(telephonyObserverClient != nullptr);
846 EXPECT_TRUE(telephonyObserverProxy != nullptr);
847 EXPECT_GE(signalInformations.size(), static_cast<size_t>(0));
848 EXPECT_GE(cellInformations.size(), static_cast<size_t>(0));
849 }
850
851 /**
852 * @tc.number TelephonyObserverTest_011
853 * @tc.name telephony observer test
854 * @tc.desc Function test
855 */
856 HWTEST_F(StateRegistryTest, TelephonyObserverTest_011, Function | MediumTest | Level1)
857 {
858 int32_t slotId = 0;
859 bool cfuResult = false;
860 std::shared_ptr<OHOS::Telephony::TelephonyObserver> telephonyObserver =
861 std::make_shared<OHOS::Telephony::TelephonyObserver>();
862 telephonyObserver->OnCfuIndicatorUpdated(slotId, cfuResult);
863 telephonyObserver->OnVoiceMailMsgIndicatorUpdated(slotId, cfuResult);
864 MessageParcel data;
865 MessageParcel reply;
866 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
867 telephonyObserver->OnIccAccountUpdatedInner(data, reply);
868 sptr<IRemoteObject> obj = sam->CheckSystemAbility(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID);
869 std::shared_ptr<OHOS::Telephony::TelephonyObserverProxy> telephonyObserverProxy =
870 std::make_shared<OHOS::Telephony::TelephonyObserverProxy>(obj);
871 telephonyObserverProxy->OnIccAccountUpdated();
872 EXPECT_TRUE(telephonyObserver != nullptr);
873 EXPECT_TRUE(telephonyObserverProxy != nullptr);
874 }
875
876 /**
877 * @tc.number TelephonyObserverTest_012
878 * @tc.name telephony observer test
879 * @tc.desc Function test
880 */
881 HWTEST_F(StateRegistryTest, TelephonyObserverTest_012, Function | MediumTest | Level1)
882 {
883 MessageOption option;
884 MessageParcel dataParcel;
885 MessageParcel reply;
886 option.SetFlags(MessageOption::TF_ASYNC);
887
888 ASSERT_TRUE(dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor()));
889 std::vector<sptr<SignalInformation>> vec;
890 std::unique_ptr<NrSignalInformation> nrSignal = std::make_unique<NrSignalInformation>();
891 ASSERT_TRUE(nrSignal != nullptr);
892 vec.push_back(nrSignal.release());
893 int32_t size = static_cast<int32_t>(vec.size());
894 dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
895 dataParcel.WriteInt32(size);
896 for (const auto &v : vec) {
897 v->Marshalling(dataParcel);
898 }
899 std::vector<sptr<SignalInformation>> signalInfos;
900 telephonyObserver.ConvertLteNrSignalInfoList(dataParcel, signalInfos, SignalInformation::NetworkType::GSM);
901 int32_t ret = telephonyObserver.OnRemoteRequest(
902 static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_SIGNAL_INFO_UPDATED), dataParcel, reply,
903 option);
904 EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
905 }
906
907 /**
908 * @tc.number TelephonyStateRegistryServiceTest_001
909 * @tc.name telephony state registry service test
910 * @tc.desc Function test
911 */
912 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_001, Function | MediumTest | Level1)
913 {
914 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
915
916 ASSERT_TRUE(service != nullptr);
917 EXPECT_TRUE(service->IsCommonEventServiceAbilityExist());
918 EXPECT_EQ(TELEPHONY_ERROR, service->GetLockReason(0));
919 EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionNetworkType(0));
920 EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataFlow(0));
921 EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionState(0));
922 EXPECT_EQ(TELEPHONY_ERROR, service->GetCardType(0));
923 EXPECT_EQ(TELEPHONY_ERROR, service->GetCallState(0));
924 EXPECT_EQ(TELEPHONY_ERROR, service->GetSimState(0));
925 service->simReason_[0] = LockReason::SIM_NONE;
926 EXPECT_EQ(TELEPHONY_ERROR, service->GetLockReason(1));
927 EXPECT_NE(TELEPHONY_ERROR, service->GetLockReason(0));
928 service->cellularDataConnectionNetworkType_[0] = 0;
929 EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionNetworkType(1));
930 EXPECT_EQ(0, service->GetCellularDataConnectionNetworkType(0));
931 service->cellularDataFlow_[0] = 0;
932 EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataFlow(1));
933 EXPECT_EQ(0, service->GetCellularDataFlow(0));
934 service->cellularDataConnectionState_[0] = 0;
935 EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionState(1));
936 EXPECT_EQ(0, service->GetCellularDataConnectionState(0));
937 service->cardType_[0] = CardType::UNKNOWN_CARD;
938 EXPECT_EQ(TELEPHONY_ERROR, service->GetCardType(1));
939 EXPECT_EQ(TELEPHONY_ERROR, service->GetCardType(0));
940 service->callState_[0] = 0;
941 EXPECT_EQ(TELEPHONY_ERROR, service->GetCallState(1));
942 EXPECT_EQ(0, service->GetCallState(0));
943 service->simState_[0] = SimState::SIM_STATE_UNKNOWN;
944 EXPECT_EQ(TELEPHONY_ERROR, service->GetSimState(1));
945 EXPECT_EQ(0, service->GetSimState(0));
946 }
947
948 /**
949 * @tc.number TelephonyStateRegistryServiceTest_002
950 * @tc.name telephony state registry service test
951 * @tc.desc Function test
952 */
953 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_002, Function | MediumTest | Level1)
954 {
955 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
956
957 ASSERT_TRUE(service != nullptr);
958 int32_t fd = -1;
959 std::vector<std::u16string> args;
960 EXPECT_EQ(TELEPHONY_ERR_FAIL, service->Dump(fd, args));
961 fd = 1;
962 EXPECT_EQ(TELEPHONY_SUCCESS, service->Dump(fd, args));
963 sptr<NetworkState> networkState = nullptr;
964 service->SendNetworkStateChanged(0, networkState);
965 TELEPHONY_EXT_WRAPPER.sendNetworkStateChanged_ = nullptr;
966 networkState = std::make_unique<NetworkState>().release();
967 service->SendNetworkStateChanged(0, networkState);
968 std::vector<sptr<SignalInformation>> vec;
969 service->SendSignalInfoChanged(0, vec);
970 TELEPHONY_EXT_WRAPPER.sendNetworkStateChanged_ = nullptr;
971 vec.push_back(std::make_unique<LteSignalInformation>().release());
972 service->SendSignalInfoChanged(0, vec);
973 std::u16string number = u"123456";
974 service->SendCallStateChanged(0, 0);
975 service->SendCallStateChangedAsUserMultiplePermission(0, 0, number);
976 TelephonyStateRegistryRecord record;
977 service->UpdateData(record);
978 record.telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
979 service->UpdateData(record);
980 record.mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE |
981 TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE |
982 TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO |
983 TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS |
984 TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE |
985 TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE |
986 TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW |
987 TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR |
988 TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR |
989 TelephonyObserverBroker::OBSERVER_MASK_ICC_ACCOUNT;
990 service->UpdateData(record);
991 EXPECT_EQ(Str8ToStr16(""), service->GetCallIncomingNumberForSlotId(record, 0));
992 TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
993 }
994
995 /**
996 * @tc.number TelephonyStateRegistryServiceTest_003
997 * @tc.name telephony state registry service test
998 * @tc.desc Function test
999 */
1000 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_003, Function | MediumTest | Level1)
1001 {
1002 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1003
1004 ASSERT_TRUE(service != nullptr);
1005 EXPECT_TRUE(service->CheckPermission(0));
1006 EXPECT_TRUE(service->CheckCallerIsSystemApp(0));
1007 EXPECT_FALSE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE));
1008 EXPECT_FALSE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
1009 EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
1010 EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR));
1011 EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR));
1012 uint32_t mask = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1013 int32_t tokenId = 123456789;
1014 pid_t pid = 1234;
1015 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UnregisterStateChange(0, mask, tokenId, pid));
1016 mask = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1017 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UnregisterStateChange(0, mask, tokenId, pid));
1018
1019 TelephonyStateRegistryRecord record;
1020 service->stateRecords_.push_back(record);
1021 service->stateRecords_[0].tokenId_ = 123456789;
1022 service->stateRecords_[0].pid_ = 1234;
1023 EXPECT_EQ(TELEPHONY_SUCCESS, service->UnregisterStateChange(0, 0, tokenId, pid));
1024 service->stateRecords_[0].tokenId_ = 123456788;
1025 EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
1026 service->stateRecords_[0].tokenId_ = -1;
1027 EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
1028 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
1029 EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
1030 service->stateRecords_[0].slotId_ = 1;
1031 EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
1032 }
1033
1034 /**
1035 * @tc.number TelephonyStateRegistryServiceTest_004
1036 * @tc.name telephony state registry service test
1037 * @tc.desc Function test
1038 */
1039 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_004, Function | MediumTest | Level1)
1040 {
1041 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1042
1043 ASSERT_TRUE(service != nullptr);
1044 if (service->state_ == ServiceRunningState::STATE_RUNNING) {
1045 service->OnStart();
1046 }
1047 sptr<TelephonyObserverBroker> telephonyObserver = nullptr;
1048 uint32_t mask = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1049 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED,
1050 service->RegisterStateChange(telephonyObserver, 0, mask, "", true, 0, 0, 0));
1051 mask = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1052 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED,
1053 service->RegisterStateChange(telephonyObserver, 0, mask, "", true, 0, 0, 0));
1054 TelephonyStateRegistryRecord record;
1055 service->stateRecords_.push_back(record);
1056 int32_t invalidSlotId = 5;
1057 EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, invalidSlotId, 0, "", true, 0, 0, 0));
1058 EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
1059 EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", false, 0, 0, 0));
1060 service->stateRecords_[0].tokenId_ = 1;
1061 EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
1062 service->stateRecords_[0].tokenId_ = 123456789;
1063 EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
1064 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
1065 EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
1066 service->stateRecords_[0].slotId_ = 1;
1067 EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
1068 }
1069
1070 /**
1071 * @tc.number TelephonyStateRegistryServiceTest_005
1072 * @tc.name telephony state registry service test
1073 * @tc.desc Function test
1074 */
1075 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_005, Function | MediumTest | Level1)
1076 {
1077 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1078
1079 ASSERT_TRUE(service != nullptr);
1080 TelephonyStateRegistryRecord record;
1081 service->stateRecords_.push_back(record);
1082 int32_t invalidSlotId = 5;
1083 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateVoiceMailMsgIndicator(invalidSlotId, true));
1084 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateVoiceMailMsgIndicator(0, true));
1085 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateIccAccount());
1086 service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
1087 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateIccAccount());
1088 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_ICC_ACCOUNT;
1089 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateIccAccount());
1090 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCfuIndicator(invalidSlotId, true));
1091 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCfuIndicator(0, true));
1092 sptr<NetworkState> networkState = std::make_unique<NetworkState>().release();
1093 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateNetworkState(invalidSlotId, networkState));
1094 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateNetworkState(0, networkState));
1095 std::vector<sptr<CellInformation>> vecCellInfo;
1096 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCellInfo(invalidSlotId, vecCellInfo));
1097 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCellInfo(0, vecCellInfo));
1098 std::vector<sptr<SignalInformation>> vecSignalInfo;
1099 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateSignalInfo(invalidSlotId, vecSignalInfo));
1100 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateSignalInfo(0, vecSignalInfo));
1101 CardType type = CardType::UNKNOWN_CARD;
1102 SimState state = SimState::SIM_STATE_UNKNOWN;
1103 LockReason reason = LockReason::SIM_NONE;
1104 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateSimState(invalidSlotId, type, state, reason));
1105 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateSimState(0, type, state, reason));
1106 std::u16string number = u"123";
1107 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCallStateForSlotId(invalidSlotId, 0, number));
1108 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCallStateForSlotId(0, 0, number));
1109 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCallState(0, number));
1110 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCellularDataFlow(invalidSlotId, 0));
1111 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCellularDataFlow(0, 0));
1112 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCellularDataConnectState(invalidSlotId, 0, 0));
1113 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCellularDataConnectState(0, 0, 0));
1114 }
1115
1116 /**
1117 * @tc.number TelephonyStateRegistryServiceTest_006
1118 * @tc.name telephony state registry service test
1119 * @tc.desc Function test
1120 */
1121 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_006, Function | MediumTest | Level1)
1122 {
1123 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1124
1125 ASSERT_TRUE(service != nullptr);
1126 AccessToken token;
1127 std::u16string number = u"123";
1128 TelephonyStateRegistryRecord record;
1129 EXPECT_FALSE(record.IsCanReadCallHistory());
1130 service->stateRecords_.push_back(record);
1131 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataConnectState(0, 0, 0));
1132 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataFlow(0, 0));
1133 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCallStateForSlotId(0, 0, number));
1134 CardType type = CardType::UNKNOWN_CARD;
1135 SimState state = SimState::SIM_STATE_UNKNOWN;
1136 LockReason reason = LockReason::SIM_NONE;
1137 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateSimState(0, type, state, reason));
1138
1139 service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
1140 service->stateRecords_[0].slotId_ = 3;
1141 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE;
1142 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataConnectState(0, 0, 0));
1143 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
1144 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataFlow(0, 0));
1145 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE;
1146 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCallState(0, number));
1147 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCallStateForSlotId(0, 0, number));
1148 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE;
1149 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateSimState(0, type, state, reason));
1150
1151 service->stateRecords_[0].slotId_ = 0;
1152 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE;
1153 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellularDataConnectState(0, 0, 0));
1154 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
1155 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellularDataFlow(0, 0));
1156 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE;
1157 service->stateRecords_[0].slotId_ = -1;
1158 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCallState(-1, number));
1159 service->stateRecords_[0].slotId_ = 0;
1160 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCallStateForSlotId(0, 0, number));
1161 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE;
1162 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateSimState(0, type, state, reason));
1163 }
1164
1165 /**
1166 * @tc.number TelephonyStateRegistryServiceTest_007
1167 * @tc.name telephony state registry service test
1168 * @tc.desc Function test
1169 */
1170 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_007, Function | MediumTest | Level1)
1171 {
1172 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1173
1174 ASSERT_TRUE(service != nullptr);
1175 AccessToken token;
1176 TelephonyStateRegistryRecord record;
1177 service->stateRecords_.push_back(record);
1178 sptr<NetworkState> networkState = std::make_unique<NetworkState>().release();
1179 std::vector<sptr<SignalInformation>> vecSignalInfo;
1180 EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateSignalInfo(0, vecSignalInfo));
1181 std::vector<sptr<CellInformation>> vecCellInfo;
1182 EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateCellInfo(0, vecCellInfo));
1183 EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateNetworkState(0, networkState));
1184 EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateCfuIndicator(0, true));
1185 EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateVoiceMailMsgIndicator(0, true));
1186
1187 service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
1188 service->stateRecords_[0].slotId_ = 3;
1189 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS;
1190 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateSignalInfo(0, vecSignalInfo));
1191 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1192 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellInfo(0, vecCellInfo));
1193 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1194 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateNetworkState(0, networkState));
1195 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR;
1196 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCfuIndicator(0, true));
1197 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR;
1198 EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateVoiceMailMsgIndicator(0, true));
1199
1200 service->stateRecords_[0].slotId_ = 0;
1201 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS;
1202 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateSignalInfo(0, vecSignalInfo));
1203 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1204 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellInfo(0, vecCellInfo));
1205 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1206 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateNetworkState(0, networkState));
1207 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR;
1208 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCfuIndicator(0, true));
1209 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR;
1210 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateVoiceMailMsgIndicator(0, true));
1211 }
1212
1213 /**
1214 * @tc.number TelephonyStateRegistryServiceTest_008
1215 * @tc.name telephony state registry service test
1216 * @tc.desc Function test
1217 */
1218 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_008, Function | MediumTest | Level1)
1219 {
1220 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1221
1222 ASSERT_TRUE(service != nullptr);
1223 AccessToken token;
1224 MessageParcel dataParcel;
1225 dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::GSM));
1226 dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::CDMA));
1227 dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::LTE));
1228 dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::NR));
1229 dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::WCDMA));
1230 dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::UNKNOWN));
1231 int32_t size = 6;
1232 std::vector<sptr<SignalInformation>> result;
1233 service->parseSignalInfos(dataParcel, size, result);
1234 MessageParcel dataSignal;
1235 service->ParseLteNrSignalInfos(dataSignal, result, SignalInformation::NetworkType::UNKNOWN);
1236 MessageParcel dataSignalNr;
1237 dataSignalNr.WriteInt32(0);
1238 dataSignalNr.WriteInt32(0);
1239 dataSignalNr.WriteInt32(0);
1240 service->ParseLteNrSignalInfos(dataSignalNr, result, SignalInformation::NetworkType::NR);
1241 MessageParcel dataSignalLte;
1242 dataSignalLte.WriteInt32(0);
1243 dataSignalLte.WriteInt32(0);
1244 dataSignalLte.WriteInt32(0);
1245 dataSignalLte.WriteInt32(0);
1246 service->ParseLteNrSignalInfos(dataSignalLte, result, SignalInformation::NetworkType::LTE);
1247
1248 TelephonyStateRegistryRecord record;
1249 std::u16string testNumber = u"123";
1250 service->callIncomingNumber_[0] = testNumber;
1251 EXPECT_EQ(u"", service->GetCallIncomingNumberForSlotId(record, 0));
1252 EXPECT_TRUE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE));
1253 EXPECT_TRUE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
1254 EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
1255 EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR));
1256 EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR));
1257 }
1258
1259 /**
1260 * @tc.number TelephonyStateRegistryServiceTest_009
1261 * @tc.name telephony state registry service test
1262 * @tc.desc Function test
1263 */
1264 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_009, Function | MediumTest | Level1)
1265 {
1266 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1267
1268 ASSERT_TRUE(service != nullptr);
1269 MessageParcel dataCellInfo;
1270 int32_t size = 4;
1271 dataCellInfo.WriteInt32(0);
1272 dataCellInfo.WriteInt32(size);
1273 dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::GSM));
1274 dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::LTE));
1275 dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::NR));
1276 dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::UNKNOWN));
1277 std::vector<sptr<SignalInformation>> result;
1278 MessageParcel reply;
1279 service->OnUpdateCellInfo(dataCellInfo, reply);
1280
1281 MessageParcel dataNetworkState;
1282 dataNetworkState.WriteInt32(0);
1283 service->OnUpdateNetworkState(dataNetworkState, reply);
1284 MessageParcel dataRegisterState;
1285 dataNetworkState.WriteInt32(0);
1286 dataNetworkState.WriteInt32(0);
1287 dataNetworkState.WriteBool(true);
1288 service->OnRegisterStateChange(dataRegisterState, reply);
1289
1290 MessageParcel dataRead;
1291 sptr<TelephonyObserverBroker> callback = nullptr;
1292 EXPECT_NE(TELEPHONY_SUCCESS, service->ReadData(dataRead, reply, callback));
1293 }
1294
1295 /**
1296 * @tc.number TelephonyStateRegistryServiceTest_010
1297 * @tc.name telephony state registry service test
1298 * @tc.desc Function test
1299 */
1300 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_010, Function | MediumTest | Level1)
1301 {
1302 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1303
1304 ASSERT_TRUE(service != nullptr);
1305 AccessToken token;
1306 TelephonyStateRegistryRecord record;
1307 service->stateRecords_.push_back(record);
1308 service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
1309 service->stateRecords_[0].slotId_ = 0;
1310 TELEPHONY_EXT_WRAPPER.onSignalInfoUpdated_ = nullptr;
1311 std::vector<sptr<SignalInformation>> vecSignalInfo;
1312 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS;
1313 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateSignalInfo(0, vecSignalInfo));
1314 TELEPHONY_EXT_WRAPPER.onCellInfoUpdated_ = nullptr;
1315 std::vector<sptr<CellInformation>> vecCellInfo;
1316 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1317 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellInfo(0, vecCellInfo));
1318 TELEPHONY_EXT_WRAPPER.onNetworkStateUpdated_ = nullptr;
1319 sptr<NetworkState> networkState = std::make_unique<NetworkState>().release();
1320 service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1321 EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateNetworkState(0, networkState));
1322 TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
1323 }
1324
1325 /**
1326 * @tc.number TelephonyStateRegistrySimCountTest_001
1327 * @tc.name telephony state registry service test
1328 * @tc.desc Function test
1329 */
1330 HWTEST_F(StateRegistryTest, TelephonyStateRegistrySimCountTest_001, Function | MediumTest | Level1)
1331 {
1332 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1333
1334 ASSERT_TRUE(service != nullptr);
1335 service->slotSize_ = MAX_SLOT_COUNT;
1336 EXPECT_TRUE(service->VerifySlotId(0));
1337 EXPECT_TRUE(service->VerifySlotId(1));
1338 EXPECT_TRUE(service->VerifySlotId(2));
1339 EXPECT_FALSE(service->VerifySlotId(3));
1340 EXPECT_FALSE(service->VerifySlotId(-1));
1341 }
1342
1343 /**
1344 * @tc.number TelephonyStateRegistrySimCountTest_002
1345 * @tc.name telephony state registry service test
1346 * @tc.desc Function test
1347 */
1348 HWTEST_F(StateRegistryTest, TelephonyStateRegistrySimCountTest_002, Function | MediumTest | Level1)
1349 {
1350 auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1351
1352 ASSERT_TRUE(service != nullptr);
1353 service->slotSize_ = DUAL_SLOT_COUNT;
1354 EXPECT_TRUE(service->VerifySlotId(0));
1355 EXPECT_TRUE(service->VerifySlotId(1));
1356 EXPECT_FALSE(service->VerifySlotId(2));
1357 EXPECT_FALSE(service->VerifySlotId(3));
1358 EXPECT_FALSE(service->VerifySlotId(-1));
1359 }
1360
1361 #else // TEL_TEST_UNSUPPORT
1362 /**
1363 * @tc.number State_MockTest_001
1364 * @tc.name Mock test for unsupport platform
1365 * @tc.desc Function test
1366 */
1367 HWTEST_F(StateRegistryTest, State_MockTest_001, Function | MediumTest | Level1)
1368 {
1369 EXPECT_TRUE(true);
1370 }
1371 #endif // TEL_TEST_UNSUPPORT
1372 } // namespace Telephony
1373 } // namespace OHOS
1374