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