1/*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15#define private public
16#define protected public
17
18#include "common_event_manager.h"
19#include "common_event_support.h"
20#include "cellular_data_constant.h"
21#include "cellular_data_handler.h"
22#include "core_manager_inner.h"
23#include "mock/mock_sim_manager.h"
24#include "mock/mock_network_search.h"
25
26namespace OHOS {
27namespace Telephony {
28using namespace testing::ext;
29using ::testing::_;
30using ::testing::AtLeast;
31using ::testing::Return;
32using ::testing::DoAll;
33using ::testing::SetArgReferee;
34
35class CellularDataHandlerBranchTest : public testing::Test {
36public:
37    CellularDataHandlerBranchTest() = default;
38    ~CellularDataHandlerBranchTest() = default;
39    static void TearDownTestCase()
40    {
41        UnmockManager();
42    }
43
44    void InitMockManager()
45    {
46        mockSimManager = new MockSimManager();
47        std::shared_ptr<MockSimManager> mockSimManagerPtr(mockSimManager);
48        CoreManagerInner::GetInstance().simManager_ = mockSimManagerPtr;
49
50        mockNetworkSearchManager = new MockNetworkSearchManager();
51        std::shared_ptr<MockNetworkSearchManager> mockNetworkSearchManagerPtr(mockNetworkSearchManager);
52        CoreManagerInner::GetInstance().networkSearchManager_ = mockNetworkSearchManagerPtr;
53    }
54
55    static void UnmockManager()
56    {
57        if (CoreManagerInner::GetInstance().simManager_ != nullptr) {
58            CoreManagerInner::GetInstance().simManager_ = nullptr;
59            std::cout << "CellularDataHandlerBranchTest set simManager_ nullptr" << std::endl;
60        }
61        if (CoreManagerInner::GetInstance().networkSearchManager_ != nullptr) {
62            CoreManagerInner::GetInstance().networkSearchManager_ = nullptr;
63            std::cout << "CellularDataHandlerBranchTest set networkSearchManager_ nullptr" << std::endl;
64        }
65    }
66
67    void InitCellularDataHandler()
68    {
69        EventFwk::MatchingSkills matchingSkills;
70        matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
71        EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
72        cellularDataHandler_ = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
73        cellularDataHandler_->Init();
74    }
75
76    std::shared_ptr<CellularDataHandler> cellularDataHandler_;
77    MockSimManager *mockSimManager;
78    MockNetworkSearchManager *mockNetworkSearchManager;
79};
80
81HWTEST_F(CellularDataHandlerBranchTest, RoamingStateOn_001, Function | MediumTest | Level3)
82{
83    InitCellularDataHandler();
84    InitMockManager();
85    // GetPsRoamingState return 1, dataRoamingEnabled is false
86    EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1));
87    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(0));
88    auto event = AppExecFwk::InnerEvent::Get(0);
89    cellularDataHandler_->RoamingStateOn(event);
90
91    // GetPsRoamingState return 1, dataRoamingEnabled is false
92    EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1));
93    EXPECT_CALL(*mockSimManager, GetSimId(_)).Times(AtLeast(0)).WillRepeatedly(Return(1));
94    cellularDataHandler_->defaultDataRoamingEnable_ = true;
95    auto event1 = AppExecFwk::InnerEvent::Get(0);
96    cellularDataHandler_->RoamingStateOn(event1);
97    EXPECT_EQ(cellularDataHandler_->apnManager_->GetOverallApnState(), PROFILE_STATE_IDLE);
98    UnmockManager();
99}
100
101HWTEST_F(CellularDataHandlerBranchTest, CheckRoamingState_001, Function | MediumTest | Level3)
102{
103    InitCellularDataHandler();
104    InitMockManager();
105    // roamingState true, dataRoamingEnabled true, isMmsApn true, isEmergencyApn false, IsRestrictedMode false
106    EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1));
107    EXPECT_CALL(*mockNetworkSearchManager, GetPsRadioTech(_, _)).WillOnce(Return(0));
108    sptr<ApnHolder> apnHolder = new ApnHolder("mms", 0);
109    ASSERT_FALSE(cellularDataHandler_ == nullptr);
110    ASSERT_FALSE(cellularDataHandler_->dataSwitchSettings_ == nullptr);
111    cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(true);
112    ASSERT_TRUE(cellularDataHandler_->CheckRoamingState(apnHolder));
113
114    // roamingState false, dataRoamingEnabled true, isMmsApn false, isEmergencyApn true, IsRestrictedMode false
115    EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(0));
116    EXPECT_CALL(*mockNetworkSearchManager, GetPsRadioTech(_, _)).WillOnce(Return(0));
117    apnHolder = new ApnHolder("emergency", 0);
118    cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(true);
119    ASSERT_TRUE(cellularDataHandler_->CheckRoamingState(apnHolder));
120
121    // roamingState true, dataRoamingEnabled false, isMmsApn true, isEmergencyApn false, IsRestrictedMode false
122    EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1));
123    apnHolder = new ApnHolder("mms", 0);
124    cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(false);
125    ASSERT_FALSE(cellularDataHandler_->CheckRoamingState(apnHolder));
126
127    // roamingState false, dataRoamingEnabled false, isMmsApn false, isEmergencyApn true, IsRestrictedMode true
128    int32_t tech = 1;
129    EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(0));
130    EXPECT_CALL(*mockNetworkSearchManager, GetPsRadioTech(_, _)).WillOnce(DoAll(SetArgReferee<1>(tech), Return(0)));
131    cellularDataHandler_->lastCallState_ = 1;
132    apnHolder = new ApnHolder("emergency", 0);
133    cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(false);
134    ASSERT_FALSE(cellularDataHandler_->CheckRoamingState(apnHolder));
135    UnmockManager();
136}
137
138HWTEST_F(CellularDataHandlerBranchTest, IsCellularDataRoamingEnabled_001, Function | MediumTest | Level3)
139{
140    EventFwk::MatchingSkills matchingSkills;
141    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
142    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
143    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2);
144
145    EXPECT_EQ(cellularDataHandler->dataSwitchSettings_, nullptr);
146    cellularDataHandler->defaultDataRoamingEnable_ = false;
147    bool result = false;
148    cellularDataHandler->IsCellularDataRoamingEnabled(result);
149    ASSERT_FALSE(result);
150
151    cellularDataHandler->Init();
152    cellularDataHandler->IsCellularDataRoamingEnabled(result);
153    ASSERT_TRUE(result);
154}
155
156HWTEST_F(CellularDataHandlerBranchTest, SetDataPermittedForMms_001, Function | MediumTest | Level3)
157{
158    EventFwk::MatchingSkills matchingSkills;
159    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
160    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
161    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2);
162
163    EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr);
164    cellularDataHandler->incallDataStateMachine_ =
165        cellularDataHandler->CreateIncallDataStateMachine(CALL_STATUS_DIALING);
166    ASSERT_FALSE(cellularDataHandler->SetDataPermittedForMms(false));
167}
168
169HWTEST_F(CellularDataHandlerBranchTest, CheckApnState_001, Function | MediumTest | Level3)
170{
171    EventFwk::MatchingSkills matchingSkills;
172    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
173    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
174    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2);
175    cellularDataHandler->Init();
176
177    sptr<ApnHolder> apnHolder = new ApnHolder("mms", 0);
178    apnHolder->SetApnState(PROFILE_STATE_DISCONNECTING);
179    ASSERT_FALSE(cellularDataHandler->CheckApnState(apnHolder));
180
181    apnHolder->SetApnState(PROFILE_STATE_FAILED);
182    ASSERT_FALSE(cellularDataHandler->CheckApnState(apnHolder));
183
184    apnHolder->SetApnState(PROFILE_STATE_CONNECTING);
185    ASSERT_FALSE(cellularDataHandler->CheckApnState(apnHolder));
186}
187
188HWTEST_F(CellularDataHandlerBranchTest, EstablishDataConnection_001, Function | MediumTest | Level3)
189{
190    EventFwk::MatchingSkills matchingSkills;
191    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
192    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
193    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2);
194    cellularDataHandler->Init();
195
196    sptr<ApnHolder> apnHolder = new ApnHolder("mms", 0);
197    ApnItem apnItem;
198    sptr<ApnItem> item = apnItem.MakeDefaultApn("mms");
199    std::vector<sptr<ApnItem>> matchedApns;
200    matchedApns.push_back(item);
201    apnHolder->SetAllMatchedApns(matchedApns);
202    cellularDataHandler->EstablishDataConnection(apnHolder, 1);
203    ASSERT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTING);
204}
205
206HWTEST_F(CellularDataHandlerBranchTest, DisconnectDataComplete_001, Function | MediumTest | Level3)
207{
208    EventFwk::MatchingSkills matchingSkills;
209    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
210    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
211    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2);
212    cellularDataHandler->Init();
213
214    auto event = AppExecFwk::InnerEvent::Get(0);
215    cellularDataHandler->DisconnectDataComplete(event);
216    ASSERT_EQ(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr);
217}
218
219HWTEST_F(CellularDataHandlerBranchTest, UpdatePhysicalConnectionState_001, Function | MediumTest | Level3)
220{
221    EventFwk::MatchingSkills matchingSkills;
222    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
223    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
224    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2);
225    cellularDataHandler->Init();
226
227    cellularDataHandler->physicalConnectionActiveState_ = true;
228    cellularDataHandler->UpdatePhysicalConnectionState(true);
229    ASSERT_FALSE(cellularDataHandler->physicalConnectionActiveState_);
230
231    cellularDataHandler->physicalConnectionActiveState_ = false;
232    cellularDataHandler->UpdatePhysicalConnectionState(true);
233    ASSERT_FALSE(cellularDataHandler->physicalConnectionActiveState_);
234
235    cellularDataHandler->physicalConnectionActiveState_ = true;
236    cellularDataHandler->UpdatePhysicalConnectionState(false);
237    ASSERT_TRUE(cellularDataHandler->physicalConnectionActiveState_);
238
239    cellularDataHandler->physicalConnectionActiveState_ = false;
240    cellularDataHandler->UpdatePhysicalConnectionState(false);
241    ASSERT_TRUE(cellularDataHandler->physicalConnectionActiveState_);
242}
243
244HWTEST_F(CellularDataHandlerBranchTest, OnReceiveEvent_001, Function | MediumTest | Level3)
245{
246    EventFwk::MatchingSkills matchingSkills;
247    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
248    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
249    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2);
250    cellularDataHandler->Init();
251
252    auto want = EventFwk::Want();
253    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
254    auto event = EventFwk::CommonEventData(want);
255    cellularDataHandler->OnReceiveEvent(event);
256    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
257
258    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED);
259    event = EventFwk::CommonEventData(want);
260    cellularDataHandler->OnReceiveEvent(event);
261    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED);
262
263    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
264    event = EventFwk::CommonEventData(want);
265    cellularDataHandler->OnReceiveEvent(event);
266    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
267
268    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
269    event = EventFwk::CommonEventData(want);
270    cellularDataHandler->OnReceiveEvent(event);
271    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
272
273    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
274    event = EventFwk::CommonEventData(want);
275    cellularDataHandler->OnReceiveEvent(event);
276    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
277
278    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY);
279    event = EventFwk::CommonEventData(want);
280    cellularDataHandler->OnReceiveEvent(event);
281    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY);
282}
283
284HWTEST_F(CellularDataHandlerBranchTest, OnReceiveEvent_002, Function | MediumTest | Level3)
285{
286    EventFwk::MatchingSkills matchingSkills;
287    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
288    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
289    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
290    cellularDataHandler->Init();
291
292    auto want = EventFwk::Want();
293    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
294    auto event = EventFwk::CommonEventData(want);
295    cellularDataHandler->OnReceiveEvent(event);
296    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
297
298    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED);
299    event = EventFwk::CommonEventData(want);
300    cellularDataHandler->OnReceiveEvent(event);
301    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED);
302
303    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
304    event = EventFwk::CommonEventData(want);
305    cellularDataHandler->OnReceiveEvent(event);
306    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
307
308    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
309    event = EventFwk::CommonEventData(want);
310    cellularDataHandler->OnReceiveEvent(event);
311    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
312
313    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
314    event = EventFwk::CommonEventData(want);
315    cellularDataHandler->OnReceiveEvent(event);
316    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
317
318    want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY);
319    event = EventFwk::CommonEventData(want);
320    cellularDataHandler->OnReceiveEvent(event);
321    ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY);
322}
323
324HWTEST_F(CellularDataHandlerBranchTest, HandleScreenStateChanged_001, Function | MediumTest | Level3)
325{
326    EventFwk::MatchingSkills matchingSkills;
327    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
328    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
329    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
330    cellularDataHandler->HandleScreenStateChanged(true);
331    ASSERT_EQ(cellularDataHandler->connectionManager_, nullptr);
332    cellularDataHandler->Init();
333    cellularDataHandler->HandleScreenStateChanged(true);
334    ASSERT_NE(cellularDataHandler->connectionManager_, nullptr);
335}
336
337HWTEST_F(CellularDataHandlerBranchTest, UpdateCellularDataConnectState_001, Function | MediumTest | Level3)
338{
339    EventFwk::MatchingSkills matchingSkills;
340    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
341    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
342    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
343    cellularDataHandler->Init();
344
345    cellularDataHandler->UpdateCellularDataConnectState("default");
346    ASSERT_NE(cellularDataHandler->apnManager_, nullptr);
347
348    cellularDataHandler->UpdateCellularDataConnectState("internal_default");
349    ASSERT_NE(cellularDataHandler->apnManager_, nullptr);
350
351    cellularDataHandler->UpdateCellularDataConnectState("mss");
352    ASSERT_NE(cellularDataHandler->apnManager_, nullptr);
353}
354
355HWTEST_F(CellularDataHandlerBranchTest, HandleDBSettingIncallChanged_001, Function | MediumTest | Level3)
356{
357    EventFwk::MatchingSkills matchingSkills;
358    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
359    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
360    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
361    cellularDataHandler->Init();
362    cellularDataHandler->HandleImsCallChanged(TelCallStatus::CALL_STATUS_DIALING);
363
364    auto event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(DataSwitchCode::CELLULAR_DATA_ENABLED));
365    cellularDataHandler->HandleDBSettingIncallChanged(event);
366    ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr);
367
368    event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(DataSwitchCode::CELLULAR_DATA_DISABLED));
369    cellularDataHandler->HandleDBSettingIncallChanged(event);
370    ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr);
371
372    cellularDataHandler->IncallDataComplete(event);
373    ASSERT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr);
374}
375
376HWTEST_F(CellularDataHandlerBranchTest, HandleImsCallChanged, Function | MediumTest | Level3)
377{
378    EventFwk::MatchingSkills matchingSkills;
379    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
380    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
381    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
382    cellularDataHandler->Init();
383
384    ASSERT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr);
385    cellularDataHandler->HandleImsCallChanged(TelCallStatus::CALL_STATUS_DIALING);
386    cellularDataHandler->HandleImsCallChanged(TelCallStatus::CALL_STATUS_INCOMING);
387    ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr);
388    cellularDataHandler->HandleVoiceCallChanged(TelCallStatus::CALL_STATUS_DISCONNECTED);
389    cellularDataHandler->HandleVoiceCallChanged(TelCallStatus::CALL_STATUS_IDLE);
390    ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr);
391}
392
393HWTEST_F(CellularDataHandlerBranchTest, ReleaseAllNetworkRequest, Function | MediumTest | Level3)
394{
395    EventFwk::MatchingSkills matchingSkills;
396    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
397    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
398    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
399    cellularDataHandler->Init();
400    cellularDataHandler->ReleaseAllNetworkRequest();
401    ASSERT_NE(cellularDataHandler->apnManager_, nullptr);
402}
403
404HWTEST_F(CellularDataHandlerBranchTest, HandleSimStateChanged, Function | MediumTest | Level3)
405{
406    InitCellularDataHandler();
407    InitMockManager();
408
409    SimState simState = SimState::SIM_STATE_READY;
410    std::u16string iccId = u"iccId";
411    EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0)));
412    EXPECT_CALL(*mockSimManager, GetSimIccId(_, _)).WillOnce(DoAll(SetArgReferee<1>(iccId), Return(0)));
413    cellularDataHandler_->HandleSimStateChanged();
414    ASSERT_NE(cellularDataHandler_->lastIccId_, iccId);
415
416    cellularDataHandler_->lastIccId_ = u"iccId";
417    EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0)));
418    EXPECT_CALL(*mockSimManager, GetSimIccId(_, _)).WillOnce(DoAll(SetArgReferee<1>(iccId), Return(0)));
419    cellularDataHandler_->HandleSimStateChanged();
420    ASSERT_EQ(cellularDataHandler_->lastIccId_, iccId);
421
422    cellularDataHandler_->isSimAccountLoaded_ = true;
423    cellularDataHandler_->isRilApnAttached_ = true;
424    simState = SimState::SIM_STATE_NOT_PRESENT;
425    EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0)));
426    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(0));
427    cellularDataHandler_->HandleSimStateChanged();
428
429    simState = SimState::SIM_STATE_NOT_READY;
430    EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0)));
431    cellularDataHandler_->HandleSimStateChanged();
432    ASSERT_FALSE(cellularDataHandler_->isSimAccountLoaded_);
433    ASSERT_FALSE(cellularDataHandler_->isRilApnAttached_);
434
435    UnmockManager();
436}
437
438HWTEST_F(CellularDataHandlerBranchTest, HandleRecordsChanged, Function | MediumTest | Level3)
439{
440    InitCellularDataHandler();
441    InitMockManager();
442
443    cellularDataHandler_->lastIccId_ = u"";
444    std::u16string iccId = u"iccId";
445    EXPECT_CALL(*mockSimManager, GetSimIccId(_, _)).WillOnce(DoAll(SetArgReferee<1>(iccId), Return(0)));
446    EXPECT_CALL(*mockSimManager, GetOperatorConfigs(_, _)).Times(AtLeast(0));
447    EXPECT_CALL(*mockSimManager, GetSimId(_)).Times(AtLeast(0));
448    EXPECT_CALL(*mockSimManager, GetSimOperatorNumeric(_, _)).Times(2);
449    EXPECT_CALL(*mockSimManager, IsCTSimCard(_, _)).Times(2);
450    cellularDataHandler_->HandleRecordsChanged();
451    ASSERT_EQ(cellularDataHandler_->lastIccId_, iccId);
452
453    UnmockManager();
454}
455
456HWTEST_F(CellularDataHandlerBranchTest, HandleSimAccountLoaded, Function | MediumTest | Level3)
457{
458    InitCellularDataHandler();
459    InitMockManager();
460
461    ASSERT_FALSE(cellularDataHandler_->isSimAccountLoaded_);
462    EXPECT_CALL(*mockSimManager, GetDefaultCellularDataSlotId()).WillOnce(Return(0));
463    EXPECT_CALL(*mockSimManager, GetSimId(_)).Times(AtLeast(0));
464    cellularDataHandler_->HandleSimAccountLoaded();
465    ASSERT_FALSE(cellularDataHandler_->isSimAccountLoaded_);
466    cellularDataHandler_->isSimAccountLoaded_ = true;
467    cellularDataHandler_->HandleSimAccountLoaded();
468    ASSERT_TRUE(cellularDataHandler_->isSimAccountLoaded_);
469
470    UnmockManager();
471}
472
473HWTEST_F(CellularDataHandlerBranchTest, SetPolicyDataOn, Function | MediumTest | Level3)
474{
475    EventFwk::MatchingSkills matchingSkills;
476    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
477    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
478    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
479    cellularDataHandler->Init();
480
481    cellularDataHandler->dataSwitchSettings_->SetPolicyDataOn(true);
482    cellularDataHandler->SetPolicyDataOn(false);
483    ASSERT_FALSE(cellularDataHandler->dataSwitchSettings_->IsPolicyDataOn());
484
485    cellularDataHandler->SetPolicyDataOn(true);
486    ASSERT_TRUE(cellularDataHandler->dataSwitchSettings_->IsPolicyDataOn());
487}
488
489HWTEST_F(CellularDataHandlerBranchTest, ChangeConnectionForDsds, Function | MediumTest | Level3)
490{
491    EventFwk::MatchingSkills matchingSkills;
492    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
493    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
494    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
495    cellularDataHandler->Init();
496
497    cellularDataHandler->ChangeConnectionForDsds(false);
498    ASSERT_TRUE(cellularDataHandler->ChangeConnectionForDsds(false));
499    ASSERT_TRUE(cellularDataHandler->ChangeConnectionForDsds(true));
500}
501
502HWTEST_F(CellularDataHandlerBranchTest, HandleDBSettingRoamingChanged, Function | MediumTest | Level3)
503{
504    EventFwk::MatchingSkills matchingSkills;
505    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
506    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
507    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
508    cellularDataHandler->Init();
509
510    auto event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED));
511    cellularDataHandler->HandleDBSettingRoamingChanged(event);
512
513    event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED));
514    cellularDataHandler->HandleDBSettingRoamingChanged(event);
515    ASSERT_EQ(event->GetParam(), 0);
516}
517
518HWTEST_F(CellularDataHandlerBranchTest, UnRegisterDataSettingObserver, Function | MediumTest | Level3)
519{
520    InitCellularDataHandler();
521    InitMockManager();
522
523    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1));
524    cellularDataHandler_->UnRegisterDataSettingObserver();
525    EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1));
526    cellularDataHandler_->RegisterDataSettingObserver();
527    ASSERT_NE(cellularDataHandler_->settingObserver_, nullptr);
528    ASSERT_NE(cellularDataHandler_->roamingObserver_, nullptr);
529    ASSERT_NE(cellularDataHandler_->incallObserver_, nullptr);
530    ASSERT_NE(cellularDataHandler_->cellularDataRdbObserver_, nullptr);
531
532    UnmockManager();
533}
534
535HWTEST_F(CellularDataHandlerBranchTest, CheckForCompatibleDataConnection, Function | MediumTest | Level3)
536{
537    EventFwk::MatchingSkills matchingSkills;
538    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
539    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
540    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
541    cellularDataHandler->Init();
542
543    sptr<ApnHolder> apnHolder = new ApnHolder("dun", 0);
544    cellularDataHandler->CheckForCompatibleDataConnection(apnHolder);
545    ASSERT_EQ(apnHolder->GetApnType(), DATA_CONTEXT_ROLE_DUN);
546}
547
548HWTEST_F(CellularDataHandlerBranchTest, ReleaseCellularDataConnection, Function | MediumTest | Level3)
549{
550    EventFwk::MatchingSkills matchingSkills;
551    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
552    EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
553    auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
554
555    cellularDataHandler->ReleaseCellularDataConnection();
556    ASSERT_EQ(cellularDataHandler->apnManager_, nullptr);
557    cellularDataHandler->Init();
558    cellularDataHandler->ReleaseCellularDataConnection();
559    ASSERT_NE(cellularDataHandler->apnManager_, nullptr);
560}
561
562}  // namespace Telephony
563}  // namespace OHOS