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 
26 namespace OHOS {
27 namespace Telephony {
28 using namespace testing::ext;
29 using ::testing::_;
30 using ::testing::AtLeast;
31 using ::testing::Return;
32 using ::testing::DoAll;
33 using ::testing::SetArgReferee;
34 
35 class CellularDataHandlerBranchTest : public testing::Test {
36 public:
37     CellularDataHandlerBranchTest() = default;
38     ~CellularDataHandlerBranchTest() = default;
TearDownTestCase()39     static void TearDownTestCase()
40     {
41         UnmockManager();
42     }
43 
InitMockManager()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 
UnmockManager()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 
InitCellularDataHandler()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 
HWTEST_F(CellularDataHandlerBranchTest, RoamingStateOn_001, Function | MediumTest | Level3)81 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, CheckRoamingState_001, Function | MediumTest | Level3)101 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, IsCellularDataRoamingEnabled_001, Function | MediumTest | Level3)138 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, SetDataPermittedForMms_001, Function | MediumTest | Level3)156 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, CheckApnState_001, Function | MediumTest | Level3)169 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, EstablishDataConnection_001, Function | MediumTest | Level3)188 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, DisconnectDataComplete_001, Function | MediumTest | Level3)206 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, UpdatePhysicalConnectionState_001, Function | MediumTest | Level3)219 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, OnReceiveEvent_001, Function | MediumTest | Level3)244 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, OnReceiveEvent_002, Function | MediumTest | Level3)284 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, HandleScreenStateChanged_001, Function | MediumTest | Level3)324 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, UpdateCellularDataConnectState_001, Function | MediumTest | Level3)337 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, HandleDBSettingIncallChanged_001, Function | MediumTest | Level3)355 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, HandleImsCallChanged, Function | MediumTest | Level3)376 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, ReleaseAllNetworkRequest, Function | MediumTest | Level3)393 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, HandleSimStateChanged, Function | MediumTest | Level3)404 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, HandleRecordsChanged, Function | MediumTest | Level3)438 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, HandleSimAccountLoaded, Function | MediumTest | Level3)456 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, SetPolicyDataOn, Function | MediumTest | Level3)473 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, ChangeConnectionForDsds, Function | MediumTest | Level3)489 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, HandleDBSettingRoamingChanged, Function | MediumTest | Level3)502 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, UnRegisterDataSettingObserver, Function | MediumTest | Level3)518 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, CheckForCompatibleDataConnection, Function | MediumTest | Level3)535 HWTEST_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 
HWTEST_F(CellularDataHandlerBranchTest, ReleaseCellularDataConnection, Function | MediumTest | Level3)548 HWTEST_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