• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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   UpdateSignalInfo_001
312  * @tc.name     update signal info
313  * @tc.desc     Function test
314  */
315 HWTEST_F(StateRegistryTest, UpdateSignalInfo_001, Function | MediumTest | Level1)
316 {
317     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
318         TELEPHONY_LOGI("no sim card!");
319     }
320     UpdateSignalInfo(DEFAULT_SIM_SLOT_ID);
321 }
322 
323 /**
324  * @tc.number   UpdateCellularDataConnectState_001
325  * @tc.name     update cellular data connect state
326  * @tc.desc     Function test
327  */
328 HWTEST_F(StateRegistryTest, UpdateCellularDataConnectState_001, Function | MediumTest | Level1)
329 {
330     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
331         TELEPHONY_LOGI("no sim card!");
332     }
333     UpdateCellularDataConnectState(DEFAULT_SIM_SLOT_ID);
334 }
335 
336 /**
337  * @tc.number   UpdateCellularDataFlow_001
338  * @tc.name     update cellular flow data
339  * @tc.desc     Function test
340  */
341 HWTEST_F(StateRegistryTest, UpdateCellularDataFlow_001, Function | MediumTest | Level1)
342 {
343     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
344         TELEPHONY_LOGI("no sim card!");
345     }
346     UpdateCellularDataFlow(DEFAULT_SIM_SLOT_ID);
347 }
348 
349 /**
350  * @tc.number   UpdateSimState_001
351  * @tc.name     update sim state
352  * @tc.desc     Function test
353  */
354 HWTEST_F(StateRegistryTest, UpdateSimState_001, Function | MediumTest | Level1)
355 {
356     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
357         TELEPHONY_LOGI("no sim card!");
358     }
359     UpdateSimState(DEFAULT_SIM_SLOT_ID);
360 }
361 
362 /**
363  * @tc.number   UpdateNetworkState_001
364  * @tc.name     update network state
365  * @tc.desc     Function test
366  */
367 HWTEST_F(StateRegistryTest, UpdateNetworkState_001, Function | MediumTest | Level1)
368 {
369     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
370         TELEPHONY_LOGI("no sim card!");
371     }
372     UpdateNetworkState(DEFAULT_SIM_SLOT_ID);
373 }
374 
375 /**
376  * @tc.number   UpdateCfuIndicator_001
377  * @tc.name     update the result of call forwarding
378  * @tc.desc     Function test
379  */
380 HWTEST_F(StateRegistryTest, UpdateCfuIndicator_001, Function | MediumTest | Level1)
381 {
382     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
383         TELEPHONY_LOGI("no sim card!");
384     }
385     UpdateCfuIndicator(DEFAULT_SIM_SLOT_ID);
386 }
387 
388 /**
389  * @tc.number   UpdateVoiceMailMsgIndicator_001
390  * @tc.name     update voice mail message indicator
391  * @tc.desc     Function test
392  */
393 HWTEST_F(StateRegistryTest, UpdateVoiceMailMsgIndicator_001, Function | MediumTest | Level1)
394 {
395     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
396         TELEPHONY_LOGI("no sim card!");
397     }
398     UpdateVoiceMailMsgIndicator(DEFAULT_SIM_SLOT_ID);
399 }
400 
401 /**
402  * @tc.number   UpdateIccAccount_001
403  * @tc.name     Update Icc Account
404  * @tc.desc     Function test
405  */
406 HWTEST_F(StateRegistryTest, UpdateIccAccount_001, Function | MediumTest | Level1)
407 {
408     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
409         TELEPHONY_LOGI("no sim card!");
410     }
411     UpdateIccAccount();
412 }
413 
414 /**
415  * @tc.number   UpdateIccAccount_002
416  * @tc.name     UpdateIccAccount
417  * @tc.desc     Function test
418  */
419 HWTEST_F(StateRegistryTest, UpdateIccAccount_002, Function | MediumTest | Level1)
420 {
421     if (!StateRegistryTest::HasSimCard(SIM_SLOT_ID_1)) {
422         TELEPHONY_LOGI("no sim card!");
423     }
424     UpdateIccAccount();
425 }
426 
427 /**
428  * @tc.number   TelephonyStateManagerTest_001
429  * @tc.name     telephony state manager add/remove state observer test
430  * @tc.desc     Function test
431  */
432 HWTEST_F(StateRegistryTest, TelephonyStateManagerTest_001, Function | MediumTest | Level1)
433 {
434     TELEPHONY_LOGI("TelephonyStateManagerTest_001 start!");
435     if (!StateRegistryTest::HasSimCard(DEFAULT_SIM_SLOT_ID)) {
436         TELEPHONY_LOGI("no sim card!");
437     }
438     TelephonyStateManager::AddStateObserver(
439         telephonyObserver0_, DEFAULT_SIM_SLOT_ID, TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE, true);
440     wptr<IRemoteObject> wptrDeath = nullptr;
441     int32_t ret = TelephonyStateManager::RemoveStateObserver(
442         DEFAULT_SIM_SLOT_ID, Telephony::TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE);
443     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
444 }
445 
446 /**
447  * @tc.number   TelephonyObserverTest_001
448  * @tc.name     telephony observer test
449  * @tc.desc     Function test
450  */
451 HWTEST_F(StateRegistryTest, TelephonyObserverTest_001, Function | MediumTest | Level1)
452 {
453     TELEPHONY_LOGI("TelephonyObserverTest_001 start!");
454     MessageParcel dataParcel;
455     MessageParcel reply;
456     MessageOption option;
457     option.SetFlags(MessageOption::TF_ASYNC);
458     std::u16string testStr = u"test";
459     if (!dataParcel.WriteInterfaceToken(testStr)) {
460         TELEPHONY_LOGE("TelephonyObserverTest_001 WriteInterfaceToken failed!");
461         return;
462     }
463     int32_t ret = telephonyObserver.OnRemoteRequest(
464         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CALL_STATE_UPDATED), dataParcel, reply,
465         option);
466     EXPECT_EQ(TELEPHONY_ERR_DESCRIPTOR_MISMATCH, ret);
467 }
468 
469 /**
470  * @tc.number   TelephonyObserverTest_002
471  * @tc.name     telephony observer test
472  * @tc.desc     Function test
473  */
474 HWTEST_F(StateRegistryTest, TelephonyObserverTest_002, Function | MediumTest | Level1)
475 {
476     TELEPHONY_LOGI("TelephonyObserverTest_002 start!");
477     MessageParcel dataParcel;
478     MessageParcel reply;
479     MessageOption option;
480     std::u16string phoneNumber = u"123456";
481     option.SetFlags(MessageOption::TF_ASYNC);
482     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
483         TELEPHONY_LOGE("TelephonyObserverTest_002 WriteInterfaceToken failed!");
484         return;
485     }
486     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
487     dataParcel.WriteInt32(CALL_STATUS_ACTIVE);
488     dataParcel.WriteString16(phoneNumber);
489     int32_t ret = telephonyObserver.OnRemoteRequest(
490         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CALL_STATE_UPDATED), dataParcel, reply,
491         option);
492     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
493 }
494 
495 /**
496  * @tc.number   TelephonyObserverTest_003
497  * @tc.name     telephony observer test
498  * @tc.desc     Function test
499  */
500 HWTEST_F(StateRegistryTest, TelephonyObserverTest_003, Function | MediumTest | Level1)
501 {
502     TELEPHONY_LOGI("TelephonyObserverTest_003 start!");
503     MessageOption option;
504     MessageParcel dataParcel;
505     MessageParcel reply;
506     option.SetFlags(MessageOption::TF_ASYNC);
507     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
508         TELEPHONY_LOGE("TelephonyObserverTest_003 WriteInterfaceToken failed!");
509         return;
510     }
511     std::vector<sptr<SignalInformation>> vec;
512     std::unique_ptr<SignalInformation> gsmSignal = std::make_unique<GsmSignalInformation>();
513     ASSERT_TRUE(gsmSignal != nullptr);
514     vec.push_back(gsmSignal.release());
515     std::unique_ptr<WcdmaSignalInformation> wcdmaSignal = std::make_unique<WcdmaSignalInformation>();
516     ASSERT_TRUE(wcdmaSignal != nullptr);
517     vec.push_back(wcdmaSignal.release());
518     std::unique_ptr<TdScdmaSignalInformation> tdScdmaSignal = std::make_unique<TdScdmaSignalInformation>();
519     ASSERT_TRUE(tdScdmaSignal != nullptr);
520     vec.push_back(tdScdmaSignal.release());
521     std::unique_ptr<CdmaSignalInformation> cdmaSignal = std::make_unique<CdmaSignalInformation>();
522     ASSERT_TRUE(cdmaSignal != nullptr);
523     vec.push_back(cdmaSignal.release());
524     std::unique_ptr<LteSignalInformation> lteSignal = std::make_unique<LteSignalInformation>();
525     ASSERT_TRUE(lteSignal != nullptr);
526     vec.push_back(lteSignal.release());
527     int32_t size = static_cast<int32_t>(vec.size());
528     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
529     dataParcel.WriteInt32(size);
530     for (const auto &v : vec) {
531         v->Marshalling(dataParcel);
532     }
533     int32_t ret = telephonyObserver.OnRemoteRequest(
534         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_SIGNAL_INFO_UPDATED), dataParcel, reply,
535         option);
536     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
537 }
538 
539 /**
540  * @tc.number   TelephonyObserverTest_004
541  * @tc.name     telephony observer test
542  * @tc.desc     Function test
543  */
544 HWTEST_F(StateRegistryTest, TelephonyObserverTest_004, Function | MediumTest | Level1)
545 {
546     TELEPHONY_LOGI("TelephonyObserverTest_004 start!");
547     MessageOption option;
548     MessageParcel dataParcel;
549     MessageParcel reply;
550     option.SetFlags(MessageOption::TF_ASYNC);
551     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
552         TELEPHONY_LOGE("TelephonyObserverTest_004 WriteInterfaceToken failed!");
553         return;
554     }
555     std::vector<sptr<CellInformation>> vec;
556     std::unique_ptr<GsmCellInformation> gsmCell = std::make_unique<GsmCellInformation>();
557     ASSERT_TRUE(gsmCell != nullptr);
558     vec.push_back(gsmCell.release());
559     std::unique_ptr<LteCellInformation> lteCell = std::make_unique<LteCellInformation>();
560     ASSERT_TRUE(lteCell != nullptr);
561     vec.push_back(lteCell.release());
562     std::unique_ptr<WcdmaCellInformation> wcdmaCell = std::make_unique<WcdmaCellInformation>();
563     ASSERT_TRUE(wcdmaCell != nullptr);
564     vec.push_back(wcdmaCell.release());
565     std::unique_ptr<NrCellInformation> nrCell = std::make_unique<NrCellInformation>();
566     ASSERT_TRUE(nrCell != nullptr);
567     vec.push_back(nrCell.release());
568     int32_t size = static_cast<int32_t>(vec.size());
569     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
570     if (!dataParcel.WriteInt32(size)) {
571         TELEPHONY_LOGE("Failed to write Cellinformation array size!");
572         return;
573     }
574     for (const auto &v : vec) {
575         v->Marshalling(dataParcel);
576     }
577     int32_t ret = telephonyObserver.OnRemoteRequest(
578         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CELL_INFO_UPDATED), dataParcel, reply,
579         option);
580     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
581 }
582 
583 /**
584  * @tc.number   TelephonyObserverTest_005
585  * @tc.name     telephony observer test
586  * @tc.desc     Function test
587  */
588 HWTEST_F(StateRegistryTest, TelephonyObserverTest_005, Function | MediumTest | Level1)
589 {
590     TELEPHONY_LOGI("TelephonyObserverTest_005 start!");
591     MessageOption option;
592     MessageParcel dataParcel;
593     MessageParcel reply;
594     option.SetFlags(MessageOption::TF_ASYNC);
595     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
596         TELEPHONY_LOGE("TelephonyObserverTest_005 WriteInterfaceToken failed!");
597         return;
598     }
599     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
600     std::unique_ptr<NetworkState> networkState = std::make_unique<NetworkState>();
601     ASSERT_TRUE(networkState != nullptr);
602     (networkState.release())->Marshalling(dataParcel);
603     int32_t ret = telephonyObserver.OnRemoteRequest(
604         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_NETWORK_STATE_UPDATED), dataParcel, reply,
605         option);
606     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
607 }
608 
609 /**
610  * @tc.number   TelephonyObserverTest_006
611  * @tc.name     telephony observer test
612  * @tc.desc     Function test
613  */
614 HWTEST_F(StateRegistryTest, TelephonyObserverTest_006, Function | MediumTest | Level1)
615 {
616     TELEPHONY_LOGI("TelephonyObserverTest_006 start!");
617     MessageOption option;
618     MessageParcel dataParcel;
619     MessageParcel reply;
620     option.SetFlags(MessageOption::TF_ASYNC);
621     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
622         TELEPHONY_LOGE("TelephonyObserverTest_006 WriteInterfaceToken failed!");
623         return;
624     }
625     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
626     dataParcel.WriteInt32(SINGLE_MODE_SIM_CARD);
627     dataParcel.WriteInt32(SIM_STATE_NOT_PRESENT);
628     dataParcel.WriteInt32(SIM_PIN);
629     int32_t ret = telephonyObserver.OnRemoteRequest(
630         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_SIM_STATE_UPDATED), dataParcel, reply,
631         option);
632     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
633 }
634 
635 /**
636  * @tc.number   TelephonyObserverTest_007
637  * @tc.name     telephony observer test
638  * @tc.desc     Function test
639  */
640 HWTEST_F(StateRegistryTest, TelephonyObserverTest_007, Function | MediumTest | Level1)
641 {
642     TELEPHONY_LOGI("TelephonyObserverTest_007 start!");
643     MessageOption option;
644     MessageParcel dataParcel;
645     MessageParcel reply;
646     option.SetFlags(MessageOption::TF_ASYNC);
647     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
648         TELEPHONY_LOGE("TelephonyObserverTest_007 WriteInterfaceToken failed!");
649         return;
650     }
651     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
652     dataParcel.WriteInt32(DATA_STATE_CONNECTING);
653     dataParcel.WriteInt32(NETWORK_TYPE_GSM);
654     int32_t ret = telephonyObserver.OnRemoteRequest(
655         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CELLULAR_DATA_CONNECT_STATE_UPDATED),
656         dataParcel, reply, option);
657     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
658 }
659 
660 /**
661  * @tc.number   TelephonyObserverTest_008
662  * @tc.name     telephony observer test
663  * @tc.desc     Function test
664  */
665 HWTEST_F(StateRegistryTest, TelephonyObserverTest_008, Function | MediumTest | Level1)
666 {
667     TELEPHONY_LOGI("TelephonyObserverTest_008 start!");
668     MessageOption option;
669     MessageParcel dataParcel;
670     MessageParcel reply;
671     option.SetFlags(MessageOption::TF_ASYNC);
672     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
673         TELEPHONY_LOGE("TelephonyObserverTest_008 WriteInterfaceToken failed!");
674         return;
675     }
676     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
677     dataParcel.WriteInt32(DATA_FLOW_TYPE_DOWN);
678     int32_t ret = telephonyObserver.OnRemoteRequest(
679         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_CELLULAR_DATA_FLOW_UPDATED), dataParcel,
680         reply, option);
681     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
682 }
683 
684 /**
685  * @tc.number   TelephonyObserverTest_009
686  * @tc.name     telephony observer test
687  * @tc.desc     Function test
688  */
689 HWTEST_F(StateRegistryTest, TelephonyObserverTest_009, Function | MediumTest | Level1)
690 {
691     TELEPHONY_LOGI("TelephonyObserverTest_009 start!");
692     MessageOption option;
693     MessageParcel dataParcel;
694     MessageParcel reply;
695     option.SetFlags(MessageOption::TF_ASYNC);
696     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
697         TELEPHONY_LOGE("TelephonyObserverTest_009 WriteInterfaceToken failed!");
698         return;
699     }
700     uint32_t testId = 123;
701     int32_t ret = telephonyObserver.OnRemoteRequest(testId, dataParcel, reply, option);
702     EXPECT_NE(TELEPHONY_ERR_SUCCESS, ret);
703 }
704 
705 /**
706  * @tc.number   TelephonyObserverTest_010
707  * @tc.name     telephony observer test
708  * @tc.desc     Function test
709  */
710 HWTEST_F(StateRegistryTest, TelephonyObserverTest_010, Function | MediumTest | Level1)
711 {
712     int32_t signalSize = 5;
713     int32_t cellInfoMaxSize = 11;
714     int32_t callState = 16;
715     std::u16string number = u"137xxxxxxxx";
716     std::unique_ptr<Telephony::TelephonyObserverClient> telephonyObserverClient =
717         std::make_unique<Telephony::TelephonyObserverClient>();
718     telephonyObserverClient->OnRemoteDied(nullptr);
719     telephonyObserverClient->proxy_ = nullptr;
720     sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
721     sptr<IRemoteObject> obj = sam->CheckSystemAbility(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID);
722     telephonyObserverClient->OnRemoteDied(obj);
723     telephonyObserverClient->proxy_ = iface_cast<ITelephonyStateNotify>(obj);
724     telephonyObserverClient->OnRemoteDied(obj);
725     std::shared_ptr<OHOS::Telephony::TelephonyObserverProxy> telephonyObserverProxy =
726         std::make_shared<OHOS::Telephony::TelephonyObserverProxy>(obj);
727     telephonyObserverProxy->OnCallStateUpdated(DEFAULT_SIM_SLOT_ID, callState, number);
728     std::vector<sptr<SignalInformation>> signalInformations;
729     telephonyObserverProxy->OnSignalInfoUpdated(DEFAULT_SIM_SLOT_ID, signalInformations);
730     for (int32_t i = 0; i < signalSize; i++) {
731         sptr<SignalInformation> signalInformation = sptr<SignalInformation>();
732         signalInformations.push_back(signalInformation);
733     }
734     telephonyObserverProxy->OnSignalInfoUpdated(DEFAULT_SIM_SLOT_ID, signalInformations);
735     std::vector<sptr<CellInformation>> cellInformations;
736     telephonyObserverProxy->OnCellInfoUpdated(DEFAULT_SIM_SLOT_ID, cellInformations);
737     for (int32_t i = 0; i < cellInfoMaxSize; i++) {
738         sptr<CellInformation> cellInfo = sptr<CellInformation>();
739         cellInformations.push_back(cellInfo);
740     }
741     telephonyObserverProxy->OnCellInfoUpdated(DEFAULT_SIM_SLOT_ID, cellInformations);
742     EXPECT_TRUE(telephonyObserverClient != nullptr);
743     EXPECT_TRUE(telephonyObserverProxy != nullptr);
744     EXPECT_GE(signalInformations.size(), static_cast<size_t>(0));
745     EXPECT_GE(cellInformations.size(), static_cast<size_t>(0));
746 }
747 
748 /**
749  * @tc.number   TelephonyObserverTest_011
750  * @tc.name     telephony observer test
751  * @tc.desc     Function test
752  */
753 HWTEST_F(StateRegistryTest, TelephonyObserverTest_011, Function | MediumTest | Level1)
754 {
755     int32_t slotId = 0;
756     bool cfuResult = false;
757     std::shared_ptr<OHOS::Telephony::TelephonyObserver> telephonyObserver =
758         std::make_shared<OHOS::Telephony::TelephonyObserver>();
759     telephonyObserver->OnCfuIndicatorUpdated(slotId, cfuResult);
760     telephonyObserver->OnVoiceMailMsgIndicatorUpdated(slotId, cfuResult);
761     MessageParcel data;
762     MessageParcel reply;
763     sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
764     telephonyObserver->OnIccAccountUpdatedInner(data, reply);
765     sptr<IRemoteObject> obj = sam->CheckSystemAbility(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID);
766     std::shared_ptr<OHOS::Telephony::TelephonyObserverProxy> telephonyObserverProxy =
767         std::make_shared<OHOS::Telephony::TelephonyObserverProxy>(obj);
768     telephonyObserverProxy->OnIccAccountUpdated();
769     EXPECT_TRUE(telephonyObserver != nullptr);
770     EXPECT_TRUE(telephonyObserverProxy != nullptr);
771 }
772 
773 /**
774  * @tc.number   TelephonyObserverTest_012
775  * @tc.name     telephony observer test
776  * @tc.desc     Function test
777  */
778 HWTEST_F(StateRegistryTest, TelephonyObserverTest_012, Function | MediumTest | Level1)
779 {
780     MessageOption option;
781     MessageParcel dataParcel;
782     MessageParcel reply;
783     option.SetFlags(MessageOption::TF_ASYNC);
784     if (!dataParcel.WriteInterfaceToken(TelephonyObserverProxy::GetDescriptor())) {
785         TELEPHONY_LOGE("TelephonyObserverTest_003 WriteInterfaceToken failed!");
786         return;
787     }
788     std::vector<sptr<SignalInformation>> vec;
789     std::unique_ptr<NrSignalInformation> nrSignal = std::make_unique<NrSignalInformation>();
790     ASSERT_TRUE(nrSignal != nullptr);
791     vec.push_back(nrSignal.release());
792     int32_t size = static_cast<int32_t>(vec.size());
793     dataParcel.WriteInt32(DEFAULT_SIM_SLOT_ID);
794     dataParcel.WriteInt32(size);
795     for (const auto &v : vec) {
796         v->Marshalling(dataParcel);
797     }
798     std::vector<sptr<SignalInformation>> signalInfos;
799     telephonyObserver.ConvertLteNrSignalInfoList(dataParcel, signalInfos, SignalInformation::NetworkType::GSM);
800     int32_t ret = telephonyObserver.OnRemoteRequest(
801         static_cast<uint32_t>(TelephonyObserverBroker::ObserverBrokerCode::ON_SIGNAL_INFO_UPDATED), dataParcel, reply,
802         option);
803     EXPECT_EQ(TELEPHONY_ERR_SUCCESS, ret);
804 }
805 
806 /**
807  * @tc.number   TelephonyStateRegistryServiceTest_001
808  * @tc.name     telephony state registry service test
809  * @tc.desc     Function test
810  */
811 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_001, Function | MediumTest | Level1)
812 {
813     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
814     if (service == nullptr) {
815         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_001 service is nullptr");
816         return;
817     }
818     EXPECT_TRUE(service->IsCommonEventServiceAbilityExist());
819     EXPECT_EQ(TELEPHONY_ERROR, service->GetLockReason(0));
820     EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionNetworkType(0));
821     EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataFlow(0));
822     EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionState(0));
823     EXPECT_EQ(TELEPHONY_ERROR, service->GetCardType(0));
824     EXPECT_EQ(TELEPHONY_ERROR, service->GetCallState(0));
825     EXPECT_EQ(TELEPHONY_ERROR, service->GetSimState(0));
826     service->simReason_[0] = LockReason::SIM_NONE;
827     EXPECT_EQ(TELEPHONY_ERROR, service->GetLockReason(1));
828     EXPECT_NE(TELEPHONY_ERROR, service->GetLockReason(0));
829     service->cellularDataConnectionNetworkType_[0] = 0;
830     EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionNetworkType(1));
831     EXPECT_EQ(0, service->GetCellularDataConnectionNetworkType(0));
832     service->cellularDataFlow_[0] = 0;
833     EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataFlow(1));
834     EXPECT_EQ(0, service->GetCellularDataFlow(0));
835     service->cellularDataConnectionState_[0] = 0;
836     EXPECT_EQ(TELEPHONY_ERROR, service->GetCellularDataConnectionState(1));
837     EXPECT_EQ(0, service->GetCellularDataConnectionState(0));
838     service->cardType_[0] = CardType::UNKNOWN_CARD;
839     EXPECT_EQ(TELEPHONY_ERROR, service->GetCardType(1));
840     EXPECT_EQ(TELEPHONY_ERROR, service->GetCardType(0));
841     service->callState_[0] = 0;
842     EXPECT_EQ(TELEPHONY_ERROR, service->GetCallState(1));
843     EXPECT_EQ(0, service->GetCallState(0));
844     service->simState_[0] = SimState::SIM_STATE_UNKNOWN;
845     EXPECT_EQ(TELEPHONY_ERROR, service->GetSimState(1));
846     EXPECT_EQ(0, service->GetSimState(0));
847 }
848 
849 /**
850  * @tc.number   TelephonyStateRegistryServiceTest_002
851  * @tc.name     telephony state registry service test
852  * @tc.desc     Function test
853  */
854 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_002, Function | MediumTest | Level1)
855 {
856     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
857     if (service == nullptr) {
858         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_002 service is nullptr");
859         return;
860     }
861     int32_t fd = -1;
862     std::vector<std::u16string> args;
863     EXPECT_EQ(TELEPHONY_ERR_FAIL, service->Dump(fd, args));
864     fd = 1;
865     EXPECT_EQ(TELEPHONY_SUCCESS, service->Dump(fd, args));
866     sptr<NetworkState> networkState = nullptr;
867     service->SendNetworkStateChanged(0, networkState);
868     TELEPHONY_EXT_WRAPPER.sendNetworkStateChanged_ = nullptr;
869     networkState = std::make_unique<NetworkState>().release();
870     service->SendNetworkStateChanged(0, networkState);
871     std::vector<sptr<SignalInformation>> vec;
872     service->SendSignalInfoChanged(0, vec);
873     TELEPHONY_EXT_WRAPPER.sendNetworkStateChanged_ = nullptr;
874     vec.push_back(std::make_unique<LteSignalInformation>().release());
875     service->SendSignalInfoChanged(0, vec);
876     std::u16string number = u"123456";
877     service->SendCallStateChanged(0, 0);
878     service->SendCallStateChangedAsUserMultiplePermission(0, 0, number);
879     TelephonyStateRegistryRecord record;
880     service->UpdateData(record);
881     record.telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
882     service->UpdateData(record);
883     record.mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE |
884                    TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE |
885                    TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO |
886                    TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS |
887                    TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE |
888                    TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE |
889                    TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW |
890                    TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR |
891                    TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR |
892                    TelephonyObserverBroker::OBSERVER_MASK_ICC_ACCOUNT;
893     service->UpdateData(record);
894     EXPECT_EQ(Str8ToStr16(""), service->GetCallIncomingNumberForSlotId(record, 0));
895     TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
896 }
897 
898 /**
899  * @tc.number   TelephonyStateRegistryServiceTest_003
900  * @tc.name     telephony state registry service test
901  * @tc.desc     Function test
902  */
903 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_003, Function | MediumTest | Level1)
904 {
905     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
906     if (service == nullptr) {
907         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_003 service is nullptr");
908         return;
909     }
910     EXPECT_TRUE(service->CheckPermission(0));
911     EXPECT_TRUE(service->CheckCallerIsSystemApp(0));
912     EXPECT_FALSE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE));
913     EXPECT_FALSE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
914     EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
915     EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR));
916     EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR));
917     uint32_t mask = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
918     int32_t tokenId = 123456789;
919     pid_t pid = 1234;
920     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UnregisterStateChange(0, mask, tokenId, pid));
921     mask = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
922     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UnregisterStateChange(0, mask, tokenId, pid));
923 
924     TelephonyStateRegistryRecord record;
925     service->stateRecords_.push_back(record);
926     service->stateRecords_[0].tokenId_ = 123456789;
927     service->stateRecords_[0].pid_ = 1234;
928     EXPECT_EQ(TELEPHONY_SUCCESS, service->UnregisterStateChange(0, 0, tokenId, pid));
929     service->stateRecords_[0].tokenId_ = 123456788;
930     EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
931     service->stateRecords_[0].tokenId_ = -1;
932     EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
933     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
934     EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
935     service->stateRecords_[0].slotId_ = 1;
936     EXPECT_EQ(TELEPHONY_STATE_UNREGISTRY_DATA_NOT_EXIST, service->UnregisterStateChange(0, 0, tokenId, pid));
937 }
938 
939 /**
940  * @tc.number   TelephonyStateRegistryServiceTest_004
941  * @tc.name     telephony state registry service test
942  * @tc.desc     Function test
943  */
944 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_004, Function | MediumTest | Level1)
945 {
946     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
947     if (service == nullptr) {
948         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_004 service is nullptr");
949         return;
950     }
951     if (service->state_ == ServiceRunningState::STATE_RUNNING) {
952         service->OnStart();
953     }
954     sptr<TelephonyObserverBroker> telephonyObserver = nullptr;
955     uint32_t mask = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
956     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED,
957         service->RegisterStateChange(telephonyObserver, 0, mask, "", true, 0, 0, 0));
958     mask = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
959     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED,
960         service->RegisterStateChange(telephonyObserver, 0, mask, "", true, 0, 0, 0));
961     TelephonyStateRegistryRecord record;
962     service->stateRecords_.push_back(record);
963     int32_t invalidSlotId = 5;
964     EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, invalidSlotId, 0, "", true, 0, 0, 0));
965     EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
966     EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", false, 0, 0, 0));
967     service->stateRecords_[0].tokenId_ = 1;
968     EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
969     service->stateRecords_[0].tokenId_ = 123456789;
970     EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
971     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
972     EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
973     service->stateRecords_[0].slotId_ = 1;
974     EXPECT_EQ(TELEPHONY_SUCCESS, service->RegisterStateChange(telephonyObserver, 0, 0, "", true, 0, 0, 0));
975 }
976 
977 /**
978  * @tc.number   TelephonyStateRegistryServiceTest_005
979  * @tc.name     telephony state registry service test
980  * @tc.desc     Function test
981  */
982 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_005, Function | MediumTest | Level1)
983 {
984     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
985     if (service == nullptr) {
986         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_005 service is nullptr");
987         return;
988     }
989     TelephonyStateRegistryRecord record;
990     service->stateRecords_.push_back(record);
991     int32_t invalidSlotId = 5;
992     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateVoiceMailMsgIndicator(invalidSlotId, true));
993     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateVoiceMailMsgIndicator(0, true));
994     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateIccAccount());
995     service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
996     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateIccAccount());
997     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_ICC_ACCOUNT;
998     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateIccAccount());
999     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCfuIndicator(invalidSlotId, true));
1000     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCfuIndicator(0, true));
1001     sptr<NetworkState> networkState = std::make_unique<NetworkState>().release();
1002     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateNetworkState(invalidSlotId, networkState));
1003     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateNetworkState(0, networkState));
1004     std::vector<sptr<CellInformation>> vecCellInfo;
1005     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCellInfo(invalidSlotId, vecCellInfo));
1006     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCellInfo(0, vecCellInfo));
1007     std::vector<sptr<SignalInformation>> vecSignalInfo;
1008     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateSignalInfo(invalidSlotId, vecSignalInfo));
1009     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateSignalInfo(0, vecSignalInfo));
1010     CardType type = CardType::UNKNOWN_CARD;
1011     SimState state = SimState::SIM_STATE_UNKNOWN;
1012     LockReason reason = LockReason::SIM_NONE;
1013     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateSimState(invalidSlotId, type, state, reason));
1014     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateSimState(0, type, state, reason));
1015     std::u16string number = u"123";
1016     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCallStateForSlotId(invalidSlotId, 0, number));
1017     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCallStateForSlotId(0, 0, number));
1018     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCallState(0, number));
1019     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCellularDataFlow(invalidSlotId, 0));
1020     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCellularDataFlow(0, 0));
1021     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_SLODID_ERROR, service->UpdateCellularDataConnectState(invalidSlotId, 0, 0));
1022     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_PERMISSION_DENIED, service->UpdateCellularDataConnectState(0, 0, 0));
1023 }
1024 
1025 /**
1026  * @tc.number   TelephonyStateRegistryServiceTest_006
1027  * @tc.name     telephony state registry service test
1028  * @tc.desc     Function test
1029  */
1030 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_006, Function | MediumTest | Level1)
1031 {
1032     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1033     if (service == nullptr) {
1034         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_006 service is nullptr");
1035         return;
1036     }
1037     AccessToken token;
1038     std::u16string number = u"123";
1039     TelephonyStateRegistryRecord record;
1040     EXPECT_FALSE(record.IsCanReadCallHistory());
1041     service->stateRecords_.push_back(record);
1042     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataConnectState(0, 0, 0));
1043     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataFlow(0, 0));
1044     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCallStateForSlotId(0, 0, number));
1045     CardType type = CardType::UNKNOWN_CARD;
1046     SimState state = SimState::SIM_STATE_UNKNOWN;
1047     LockReason reason = LockReason::SIM_NONE;
1048     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateSimState(0, type, state, reason));
1049 
1050     service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
1051     service->stateRecords_[0].slotId_ = 3;
1052     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE;
1053     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataConnectState(0, 0, 0));
1054     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
1055     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellularDataFlow(0, 0));
1056     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE;
1057     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCallState(0, number));
1058     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCallStateForSlotId(0, 0, number));
1059     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE;
1060     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateSimState(0, type, state, reason));
1061 
1062     service->stateRecords_[0].slotId_ = 0;
1063     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_CONNECTION_STATE;
1064     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellularDataConnectState(0, 0, 0));
1065     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_DATA_FLOW;
1066     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellularDataFlow(0, 0));
1067     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE;
1068     service->stateRecords_[0].slotId_ = -1;
1069     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCallState(-1, number));
1070     service->stateRecords_[0].slotId_ = 0;
1071     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCallStateForSlotId(0, 0, number));
1072     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIM_STATE;
1073     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateSimState(0, type, state, reason));
1074 }
1075 
1076 /**
1077  * @tc.number   TelephonyStateRegistryServiceTest_007
1078  * @tc.name     telephony state registry service test
1079  * @tc.desc     Function test
1080  */
1081 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_007, Function | MediumTest | Level1)
1082 {
1083     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1084     if (service == nullptr) {
1085         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_007 service is nullptr");
1086         return;
1087     }
1088     AccessToken token;
1089     TelephonyStateRegistryRecord record;
1090     service->stateRecords_.push_back(record);
1091     sptr<NetworkState> networkState = std::make_unique<NetworkState>().release();
1092     std::vector<sptr<SignalInformation>> vecSignalInfo;
1093     EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateSignalInfo(0, vecSignalInfo));
1094     std::vector<sptr<CellInformation>> vecCellInfo;
1095     EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateCellInfo(0, vecCellInfo));
1096     EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateNetworkState(0, networkState));
1097     EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateCfuIndicator(0, true));
1098     EXPECT_NE(TELEPHONY_SUCCESS, service->UpdateVoiceMailMsgIndicator(0, true));
1099 
1100     service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
1101     service->stateRecords_[0].slotId_ = 3;
1102     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS;
1103     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateSignalInfo(0, vecSignalInfo));
1104     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1105     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCellInfo(0, vecCellInfo));
1106     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1107     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateNetworkState(0, networkState));
1108     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR;
1109     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateCfuIndicator(0, true));
1110     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR;
1111     EXPECT_EQ(TELEPHONY_STATE_REGISTRY_DATA_NOT_EXIST, service->UpdateVoiceMailMsgIndicator(0, true));
1112 
1113     service->stateRecords_[0].slotId_ = 0;
1114     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS;
1115     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateSignalInfo(0, vecSignalInfo));
1116     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1117     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellInfo(0, vecCellInfo));
1118     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1119     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateNetworkState(0, networkState));
1120     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR;
1121     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCfuIndicator(0, true));
1122     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR;
1123     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateVoiceMailMsgIndicator(0, true));
1124 }
1125 
1126 /**
1127  * @tc.number   TelephonyStateRegistryServiceTest_008
1128  * @tc.name     telephony state registry service test
1129  * @tc.desc     Function test
1130  */
1131 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_008, Function | MediumTest | Level1)
1132 {
1133     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1134     if (service == nullptr) {
1135         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_008 service is nullptr");
1136         return;
1137     }
1138     AccessToken token;
1139     MessageParcel dataParcel;
1140     dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::GSM));
1141     dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::CDMA));
1142     dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::LTE));
1143     dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::NR));
1144     dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::WCDMA));
1145     dataParcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::UNKNOWN));
1146     int32_t size = 6;
1147     std::vector<sptr<SignalInformation>> result;
1148     service->parseSignalInfos(dataParcel, size, result);
1149     MessageParcel dataSignal;
1150     service->ParseLteNrSignalInfos(dataSignal, result, SignalInformation::NetworkType::UNKNOWN);
1151     MessageParcel dataSignalNr;
1152     dataSignalNr.WriteInt32(0);
1153     dataSignalNr.WriteInt32(0);
1154     dataSignalNr.WriteInt32(0);
1155     service->ParseLteNrSignalInfos(dataSignalNr, result, SignalInformation::NetworkType::NR);
1156     MessageParcel dataSignalLte;
1157     dataSignalLte.WriteInt32(0);
1158     dataSignalLte.WriteInt32(0);
1159     dataSignalLte.WriteInt32(0);
1160     dataSignalLte.WriteInt32(0);
1161     service->ParseLteNrSignalInfos(dataSignalLte, result, SignalInformation::NetworkType::LTE);
1162 
1163     TelephonyStateRegistryRecord record;
1164     std::u16string testNumber = u"123";
1165     service->callIncomingNumber_[0] = testNumber;
1166     EXPECT_EQ(u"", service->GetCallIncomingNumberForSlotId(record, 0));
1167     EXPECT_TRUE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE));
1168     EXPECT_TRUE(service->CheckPermission(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
1169     EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO));
1170     EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_CFU_INDICATOR));
1171     EXPECT_TRUE(service->CheckCallerIsSystemApp(TelephonyObserverBroker::OBSERVER_MASK_VOICE_MAIL_MSG_INDICATOR));
1172 }
1173 
1174 /**
1175  * @tc.number   TelephonyStateRegistryServiceTest_009
1176  * @tc.name     telephony state registry service test
1177  * @tc.desc     Function test
1178  */
1179 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_009, Function | MediumTest | Level1)
1180 {
1181     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1182     if (service == nullptr) {
1183         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_009 service is nullptr");
1184         return;
1185     }
1186     MessageParcel dataCellInfo;
1187     int32_t size = 4;
1188     dataCellInfo.WriteInt32(0);
1189     dataCellInfo.WriteInt32(size);
1190     dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::GSM));
1191     dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::LTE));
1192     dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::NR));
1193     dataCellInfo.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::UNKNOWN));
1194     std::vector<sptr<SignalInformation>> result;
1195     MessageParcel reply;
1196     service->OnUpdateCellInfo(dataCellInfo, reply);
1197 
1198     MessageParcel dataNetworkState;
1199     dataNetworkState.WriteInt32(0);
1200     service->OnUpdateNetworkState(dataNetworkState, reply);
1201     MessageParcel dataRegisterState;
1202     dataNetworkState.WriteInt32(0);
1203     dataNetworkState.WriteInt32(0);
1204     dataNetworkState.WriteBool(true);
1205     service->OnRegisterStateChange(dataRegisterState, reply);
1206 
1207     MessageParcel dataRead;
1208     sptr<TelephonyObserverBroker> callback = nullptr;
1209     EXPECT_NE(TELEPHONY_SUCCESS, service->ReadData(dataRead, reply, callback));
1210 }
1211 
1212 /**
1213  * @tc.number   TelephonyStateRegistryServiceTest_010
1214  * @tc.name     telephony state registry service test
1215  * @tc.desc     Function test
1216  */
1217 HWTEST_F(StateRegistryTest, TelephonyStateRegistryServiceTest_010, Function | MediumTest | Level1)
1218 {
1219     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1220     if (service == nullptr) {
1221         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_010 service is nullptr");
1222         return;
1223     }
1224     AccessToken token;
1225     TelephonyStateRegistryRecord record;
1226     service->stateRecords_.push_back(record);
1227     service->stateRecords_[0].telephonyObserver_ = std::make_unique<TelephonyObserver>().release();
1228     service->stateRecords_[0].slotId_ = 0;
1229     TELEPHONY_EXT_WRAPPER.onSignalInfoUpdated_ = nullptr;
1230     std::vector<sptr<SignalInformation>> vecSignalInfo;
1231     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS;
1232     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateSignalInfo(0, vecSignalInfo));
1233     TELEPHONY_EXT_WRAPPER.onCellInfoUpdated_ = nullptr;
1234     std::vector<sptr<CellInformation>> vecCellInfo;
1235     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_CELL_INFO;
1236     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateCellInfo(0, vecCellInfo));
1237     TELEPHONY_EXT_WRAPPER.onNetworkStateUpdated_ = nullptr;
1238     sptr<NetworkState> networkState = std::make_unique<NetworkState>().release();
1239     service->stateRecords_[0].mask_ = TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE;
1240     EXPECT_EQ(TELEPHONY_SUCCESS, service->UpdateNetworkState(0, networkState));
1241     TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
1242 }
1243 
1244 /**
1245  * @tc.number   TelephonyStateRegistrySimCountTest_001
1246  * @tc.name     telephony state registry service test
1247  * @tc.desc     Function test
1248  */
1249 HWTEST_F(StateRegistryTest, TelephonyStateRegistrySimCountTest_001, Function | MediumTest | Level1)
1250 {
1251     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1252     if (service == nullptr) {
1253         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_001 service is nullptr");
1254         return;
1255     }
1256     service->slotSize_ = MAX_SLOT_COUNT;
1257     EXPECT_TRUE(service->VerifySlotId(0));
1258     EXPECT_TRUE(service->VerifySlotId(1));
1259     EXPECT_TRUE(service->VerifySlotId(2));
1260     EXPECT_FALSE(service->VerifySlotId(3));
1261     EXPECT_FALSE(service->VerifySlotId(-1));
1262 }
1263 
1264 /**
1265  * @tc.number   TelephonyStateRegistrySimCountTest_002
1266  * @tc.name     telephony state registry service test
1267  * @tc.desc     Function test
1268  */
1269 HWTEST_F(StateRegistryTest, TelephonyStateRegistrySimCountTest_002, Function | MediumTest | Level1)
1270 {
1271     auto service = DelayedSingleton<TelephonyStateRegistryService>::GetInstance();
1272     if (service == nullptr) {
1273         TELEPHONY_LOGE("TelephonyStateRegistryServiceTest_001 service is nullptr");
1274         return;
1275     }
1276     service->slotSize_ = DUAL_SLOT_COUNT;
1277     EXPECT_TRUE(service->VerifySlotId(0));
1278     EXPECT_TRUE(service->VerifySlotId(1));
1279     EXPECT_FALSE(service->VerifySlotId(2));
1280     EXPECT_FALSE(service->VerifySlotId(3));
1281     EXPECT_FALSE(service->VerifySlotId(-1));
1282 }
1283 
1284 #else // TEL_TEST_UNSUPPORT
1285 /**
1286  * @tc.number   State_MockTest_001
1287  * @tc.name     Mock test for unsupport platform
1288  * @tc.desc     Function test
1289  */
1290 HWTEST_F(StateRegistryTest, State_MockTest_001, Function | MediumTest | Level1)
1291 {
1292     EXPECT_TRUE(true);
1293 }
1294 #endif // TEL_TEST_UNSUPPORT
1295 } // namespace Telephony
1296 } // namespace OHOS
1297