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 "gtest/gtest.h"
19 #include "common_event_manager.h"
20 #include "common_event_support.h"
21 #include "cellular_data_handler.h"
22
23 namespace OHOS {
24 namespace Telephony {
25 using namespace testing::ext;
26
27 class CellularDataHandlerTest : public testing::Test {
28 public:
SetUpTestCase()29 static void SetUpTestCase() {}
TearDownTestCase()30 static void TearDownTestCase() {}
SetUp()31 void SetUp() {}
TearDown()32 void TearDown() {}
33 };
34
35 /**
36 * @tc.number HandleUpdateNetInfo_001
37 * @tc.name test error branch
38 * @tc.desc Function test
39 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_001, Function | MediumTest | Level3)40 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_001, Function | MediumTest | Level3)
41 {
42 EventFwk::MatchingSkills matchingSkills;
43 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
44 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
45 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
46 auto netInfo = std::make_shared<SetupDataCallResultInfo>();
47 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo);
48 cellularDataHandler->HandleUpdateNetInfo(event);
49 EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr);
50 EXPECT_EQ(cellularDataHandler->apnManager_, nullptr);
51 }
52
53 /**
54 * @tc.number HandleUpdateNetInfo_002
55 * @tc.name test error branch
56 * @tc.desc Function test
57 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_002, Function | MediumTest | Level3)58 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_002, Function | MediumTest | Level3)
59 {
60 EventFwk::MatchingSkills matchingSkills;
61 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
62 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
63 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
64 cellularDataHandler->Init();
65 auto netInfo = std::make_shared<SetupDataCallResultInfo>();
66 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED);
67 cellularDataHandler->HandleUpdateNetInfo(event);
68 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
69 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
70 EXPECT_EQ(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr);
71 }
72
73 /**
74 * @tc.number HandleUpdateNetInfo_003
75 * @tc.name test error branch
76 * @tc.desc Function test
77 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_003, Function | MediumTest | Level3)78 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_003, Function | MediumTest | Level3)
79 {
80 EventFwk::MatchingSkills matchingSkills;
81 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
82 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
83 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
84 cellularDataHandler->Init();
85 auto netInfo = std::make_shared<SetupDataCallResultInfo>();
86 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
87 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo);
88 cellularDataHandler->HandleUpdateNetInfo(event);
89 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
90 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
91 EXPECT_NE(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr);
92 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder(
93 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag));
94 EXPECT_NE(apnHolder, nullptr);
95 EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_IDLE);
96 }
97
98 /**
99 * @tc.number HandleUpdateNetInfo_004
100 * @tc.name test error branch
101 * @tc.desc Function test
102 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_004, Function | MediumTest | Level3)103 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_004, Function | MediumTest | Level3)
104 {
105 EventFwk::MatchingSkills matchingSkills;
106 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
107 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
108 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
109 cellularDataHandler->Init();
110 auto netInfo = std::make_shared<SetupDataCallResultInfo>();
111 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
112 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder(
113 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag));
114 EXPECT_NE(apnHolder, nullptr);
115 apnHolder->SetApnState(PROFILE_STATE_CONNECTED);
116 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo);
117 cellularDataHandler->HandleUpdateNetInfo(event);
118 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
119 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
120 EXPECT_NE(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr);
121 EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTED);
122 auto stateMachine = cellularDataHandler->connectionManager_->GetActiveConnectionByCid(netInfo->cid);
123 EXPECT_EQ(stateMachine, nullptr);
124 }
125
126 /**
127 * @tc.number HandleUpdateNetInfo_005
128 * @tc.name test error branch
129 * @tc.desc Function test
130 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_005, Function | MediumTest | Level3)131 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_005, Function | MediumTest | Level3)
132 {
133 EventFwk::MatchingSkills matchingSkills;
134 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
135 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
136 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
137 cellularDataHandler->Init();
138 auto netInfo = std::make_shared<SetupDataCallResultInfo>();
139 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
140 netInfo->cid = 100;
141 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder(
142 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag));
143 EXPECT_NE(apnHolder, nullptr);
144 apnHolder->SetApnState(PROFILE_STATE_CONNECTED);
145 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release();
146 EXPECT_NE(connectionManager, nullptr);
147 connectionManager->Init();
148 auto sm = std::make_shared<CellularDataStateMachine>(
149 connectionManager, std::make_shared<TelEventHandler>("CellularDataHandlerTest"));
150 sm->cid_ = 100;
151 cellularDataHandler->connectionManager_->AddActiveConnectionByCid(sm);
152 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo);
153 cellularDataHandler->HandleUpdateNetInfo(event);
154 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
155 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
156 EXPECT_NE(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr);
157 EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTED);
158 auto stateMachine = cellularDataHandler->connectionManager_->GetActiveConnectionByCid(netInfo->cid);
159 EXPECT_NE(stateMachine, nullptr);
160 }
161
162 /**
163 * @tc.number HandleUpdateNetInfo_006
164 * @tc.name test error branch
165 * @tc.desc Function test
166 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_006, Function | MediumTest | Level3)167 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_006, Function | MediumTest | Level3)
168 {
169 EventFwk::MatchingSkills matchingSkills;
170 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
171 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
172 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
173 cellularDataHandler->Init();
174 auto netInfo = std::make_shared<SetupDataCallResultInfo>();
175 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
176 netInfo->cid = 100;
177 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder(
178 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag));
179 EXPECT_NE(apnHolder, nullptr);
180 apnHolder->SetApnState(PROFILE_STATE_IDLE);
181 cellularDataHandler->ClearConnection(apnHolder, DisConnectionReason::REASON_CLEAR_CONNECTION);
182 EXPECT_NE(apnHolder->GetApnState(), PROFILE_STATE_DISCONNECTING);
183 }
184
185 /**
186 * @tc.number HandleRoamingOff_001
187 * @tc.name test roaming off
188 * @tc.desc Function test
189 */
HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_001, Function | MediumTest | Level3)190 HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_001, Function | MediumTest | Level3)
191 {
192 EventFwk::MatchingSkills matchingSkills;
193 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
194 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
195 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
196 cellularDataHandler->Init();
197 cellularDataHandler->SetCellularDataRoamingEnabled(true);
198 auto event = AppExecFwk::InnerEvent::Get(0);
199 cellularDataHandler->RoamingStateOff(event);
200 }
201
202 /**
203 * @tc.number HandleRoamingOff_002
204 * @tc.name test roaming off
205 * @tc.desc Function test
206 */
HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_002, Function | MediumTest | Level3)207 HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_002, Function | MediumTest | Level3)
208 {
209 EventFwk::MatchingSkills matchingSkills;
210 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
211 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
212 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
213 cellularDataHandler->Init();
214 cellularDataHandler->SetCellularDataRoamingEnabled(false);
215 auto event = AppExecFwk::InnerEvent::Get(0);
216 cellularDataHandler->RoamingStateOff(event);
217 }
218
219 /**
220 * @tc.number HandleSimEvent_001
221 * @tc.name test error branch
222 * @tc.desc Function test
223 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_001, Function | MediumTest | Level3)224 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_001, Function | MediumTest | Level3)
225 {
226 EventFwk::MatchingSkills matchingSkills;
227 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
228 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
229 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
230 cellularDataHandler->Init();
231 AppExecFwk::InnerEvent::Pointer nullEvent(nullptr, nullptr);
232 cellularDataHandler->HandleSimEvent(nullEvent);
233 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, 0);
234 cellularDataHandler->HandleSimEvent(event);
235 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
236 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
237 }
238
239 /**
240 * @tc.number HandleSimEvent_002
241 * @tc.name test error branch
242 * @tc.desc Function test
243 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_002, Function | MediumTest | Level3)244 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_002, 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, 0);
250 cellularDataHandler->Init();
251 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 1);
252 cellularDataHandler->HandleSimEvent(event);
253 EXPECT_NE(cellularDataHandler->slotId_, event->GetParam());
254 }
255
256 /**
257 * @tc.number HandleSimEvent_003
258 * @tc.name test error branch
259 * @tc.desc Function test
260 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_003, Function | MediumTest | Level3)261 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_003, Function | MediumTest | Level3)
262 {
263 EventFwk::MatchingSkills matchingSkills;
264 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
265 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
266 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
267 cellularDataHandler->Init();
268 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 0);
269 cellularDataHandler->HandleSimEvent(event);
270 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_STATE_CHANGE);
271 }
272
273 /**
274 * @tc.number HandleSimEvent_004
275 * @tc.name test error branch
276 * @tc.desc Function test
277 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_004, Function | MediumTest | Level3)278 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_004, Function | MediumTest | Level3)
279 {
280 EventFwk::MatchingSkills matchingSkills;
281 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
282 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
283 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
284 cellularDataHandler->Init();
285 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_RECORDS_LOADED, 0);
286 cellularDataHandler->HandleSimEvent(event);
287 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_RECORDS_LOADED);
288 }
289
290 /**
291 * @tc.number HandleSimEvent_005
292 * @tc.name test error branch
293 * @tc.desc Function test
294 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_005, Function | MediumTest | Level3)295 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_005, Function | MediumTest | Level3)
296 {
297 EventFwk::MatchingSkills matchingSkills;
298 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
299 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
300 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
301 cellularDataHandler->Init();
302 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NV_REFRESH_FINISHED, 0);
303 cellularDataHandler->HandleSimEvent(event);
304 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_NV_REFRESH_FINISHED);
305 }
306
307 /**
308 * @tc.number HandleSimEvent_006
309 * @tc.name test error branch
310 * @tc.desc Function test
311 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_006, Function | MediumTest | Level3)312 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_006, Function | MediumTest | Level3)
313 {
314 EventFwk::MatchingSkills matchingSkills;
315 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
316 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
317 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
318 cellularDataHandler->Init();
319 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ACCOUNT_LOADED, 0);
320 cellularDataHandler->HandleSimEvent(event);
321 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
322 }
323
324 /**
325 * @tc.number ClearConnectionsOnUpdateApns_001
326 * @tc.name test error branch
327 * @tc.desc Function test
328 */
HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_001, Function | MediumTest | Level3)329 HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_001, Function | MediumTest | Level3)
330 {
331 EventFwk::MatchingSkills matchingSkills;
332 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
333 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
334 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
335 cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION);
336 EXPECT_EQ(cellularDataHandler->apnManager_, nullptr);
337 }
338
339 /**
340 * @tc.number ClearConnectionsOnUpdateApns_002
341 * @tc.name test error branch
342 * @tc.desc Function test
343 */
HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_002, Function | MediumTest | Level3)344 HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_002, Function | MediumTest | Level3)
345 {
346 EventFwk::MatchingSkills matchingSkills;
347 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
348 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
349 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
350 cellularDataHandler->Init();
351 cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION);
352 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
353 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
354 }
355
356 /**
357 * @tc.number CellularDataHandler_Uid_Test001
358 * @tc.name test error branch
359 * @tc.desc Function test
360 */
HWTEST_F(CellularDataHandlerTest, CellularDataHandler_Uid_Test001, Function | MediumTest | Level3)361 HWTEST_F(CellularDataHandlerTest, CellularDataHandler_Uid_Test001, Function | MediumTest | Level3)
362 {
363 EventFwk::MatchingSkills matchingSkills;
364 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
365 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
366 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
367 NetRequest netRequest;
368 netRequest.capability = 1;
369 netRequest.ident = "ident";
370 EXPECT_FALSE(cellularDataHandler->AddUid(netRequest));
371 EXPECT_FALSE(cellularDataHandler->RemoveUid(netRequest));
372 cellularDataHandler->Init();
373 EXPECT_TRUE(cellularDataHandler->AddUid(netRequest));
374 EXPECT_TRUE(cellularDataHandler->RemoveUid(netRequest));
375 }
376
377 /**
378 * @tc.number SetCellularDataRoamingEnabledTest001
379 * @tc.name test error branch
380 * @tc.desc Function test
381 */
HWTEST_F(CellularDataHandlerTest, SetCellularDataRoamingEnabledTest001, Function | MediumTest | Level3)382 HWTEST_F(CellularDataHandlerTest, SetCellularDataRoamingEnabledTest001, Function | MediumTest | Level3)
383 {
384 EventFwk::MatchingSkills matchingSkills;
385 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
386 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
387 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
388 bool dataRoamingEnabled = true;
389 EXPECT_EQ(cellularDataHandler->SetCellularDataRoamingEnabled(dataRoamingEnabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
390 cellularDataHandler->Init();
391 auto event = AppExecFwk::InnerEvent::Get(0);
392 cellularDataHandler->RadioPsConnectionAttached(event);
393 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
394 cellularDataHandler->RoamingStateOn(event);
395 cellularDataHandler->RoamingStateOff(event);
396 EXPECT_NE(cellularDataHandler->dataSwitchSettings_, nullptr);
397 cellularDataHandler->incallDataStateMachine_ = cellularDataHandler->CreateIncallDataStateMachine(0);
398 EXPECT_FALSE(cellularDataHandler->SetDataPermittedForMms(true));
399 }
400
401 /**
402 * @tc.number AttemptEstablishDataConnectionTest001
403 * @tc.name test error branch
404 * @tc.desc Function test
405 */
HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest001, Function | MediumTest | Level3)406 HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest001, Function | MediumTest | Level3)
407 {
408 EventFwk::MatchingSkills matchingSkills;
409 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
410 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
411 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
412 cellularDataHandler->Init();
413 std::shared_ptr<CellularDataStateMachine> cellularMachine = nullptr;
414 cellularDataHandler->connectionManager_->GetAllConnectionMachine().push_back(cellularMachine);
415 EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr);
416 }
417
418 /**
419 * @tc.number AttemptEstablishDataConnectionTest002
420 * @tc.name test error branch
421 * @tc.desc Function test
422 */
HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest002, Function | MediumTest | Level3)423 HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest002, Function | MediumTest | Level3)
424 {
425 EventFwk::MatchingSkills matchingSkills;
426 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
427 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
428 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
429 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release();
430 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
431 connectionManager, nullptr);
432 cellularDataHandler->connectionManager_ = connectionManager;
433 cellularDataHandler->connectionManager_->GetAllConnectionMachine().push_back(cellularMachine);
434 EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr);
435 cellularDataHandler->Init();
436 EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr);
437 }
438
439 /**
440 * @tc.number EstablishDataConnectionTest002
441 * @tc.name test error branch
442 * @tc.desc Function test
443 */
HWTEST_F(CellularDataHandlerTest, EstablishDataConnectionTest002, Function | MediumTest | Level3)444 HWTEST_F(CellularDataHandlerTest, EstablishDataConnectionTest002, Function | MediumTest | Level3)
445 {
446 EventFwk::MatchingSkills matchingSkills;
447 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
448 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
449 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
450 cellularDataHandler->Init();
451 sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
452 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
453 apnHolder->retryPolicy_.matchedApns_.push_back(apnItem);
454 EXPECT_NE(apnHolder->GetNextRetryApn(), nullptr);
455 EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0));
456 apnHolder->apnType_ = DATA_CONTEXT_ROLE_DUN;
457 EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0));
458 apnHolder->apnType_ = DATA_CONTEXT_ROLE_MMS;
459 EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0));
460 }
461
462 /**
463 * @tc.number DisconnectDataCompleteTest001
464 * @tc.name test error branch
465 * @tc.desc Function test
466 */
HWTEST_F(CellularDataHandlerTest, DisconnectDataCompleteTest001, Function | MediumTest | Level3)467 HWTEST_F(CellularDataHandlerTest, DisconnectDataCompleteTest001, Function | MediumTest | Level3)
468 {
469 EventFwk::MatchingSkills matchingSkills;
470 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
471 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
472 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
473 cellularDataHandler->Init();
474 auto event = AppExecFwk::InnerEvent::Get(0);
475 cellularDataHandler->DisconnectDataComplete(event);
476 EXPECT_NE(event, nullptr);
477 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
478 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
479 }
480
481 /**
482 * @tc.number UpdatePhysicalConnectionStateTest001
483 * @tc.name test error branch
484 * @tc.desc Function test
485 */
HWTEST_F(CellularDataHandlerTest, UpdatePhysicalConnectionStateTest001, Function | MediumTest | Level3)486 HWTEST_F(CellularDataHandlerTest, UpdatePhysicalConnectionStateTest001, Function | MediumTest | Level3)
487 {
488 EventFwk::MatchingSkills matchingSkills;
489 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
490 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
491 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
492 cellularDataHandler->physicalConnectionActiveState_ = false;
493 cellularDataHandler->UpdatePhysicalConnectionState(false);
494 EXPECT_TRUE(cellularDataHandler->physicalConnectionActiveState_);
495
496 cellularDataHandler->UpdatePhysicalConnectionState(true);
497 EXPECT_FALSE(cellularDataHandler->physicalConnectionActiveState_);
498
499 cellularDataHandler->physicalConnectionActiveState_ = true;
500 cellularDataHandler->UpdatePhysicalConnectionState(false);
501 EXPECT_TRUE(cellularDataHandler->physicalConnectionActiveState_);
502
503 cellularDataHandler->UpdatePhysicalConnectionState(true);
504 EXPECT_FALSE(cellularDataHandler->physicalConnectionActiveState_);
505 }
506
507 /**
508 * @tc.number HandleScreenStateChangedTest001
509 * @tc.name test error branch
510 * @tc.desc Function test
511 */
HWTEST_F(CellularDataHandlerTest, HandleScreenStateChangedTest001, Function | MediumTest | Level3)512 HWTEST_F(CellularDataHandlerTest, HandleScreenStateChangedTest001, Function | MediumTest | Level3)
513 {
514 EventFwk::MatchingSkills matchingSkills;
515 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
516 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
517 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
518 cellularDataHandler->HandleScreenStateChanged(false);
519 EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr);
520 cellularDataHandler->Init();
521 cellularDataHandler->HandleScreenStateChanged(false);
522 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
523 }
524
525 /**
526 * @tc.number UpdateCellularDataConnectStateTest001
527 * @tc.name test error branch
528 * @tc.desc Function test
529 */
HWTEST_F(CellularDataHandlerTest, UpdateCellularDataConnectStateTest001, Function | MediumTest | Level3)530 HWTEST_F(CellularDataHandlerTest, UpdateCellularDataConnectStateTest001, Function | MediumTest | Level3)
531 {
532 EventFwk::MatchingSkills matchingSkills;
533 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
534 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
535 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
536 cellularDataHandler->Init();
537 cellularDataHandler->incallDataStateMachine_ = cellularDataHandler->CreateIncallDataStateMachine(0);
538 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
539 cellularDataHandler->IncallDataComplete(event);
540 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr);
541 cellularDataHandler->UpdateCellularDataConnectState("default");
542 EXPECT_EQ(cellularDataHandler->apnManager_->GetOverallDefaultApnState(), 0);
543 cellularDataHandler->UpdateCellularDataConnectState("internal_default");
544 EXPECT_EQ(cellularDataHandler->apnManager_->GetOverallDefaultApnState(), 0);
545 }
546
547 /**
548 * @tc.number HandleImsCallChangedTest001
549 * @tc.name test error branch
550 * @tc.desc Function test
551 */
HWTEST_F(CellularDataHandlerTest, HandleImsCallChangedTest001, Function | MediumTest | Level3)552 HWTEST_F(CellularDataHandlerTest, HandleImsCallChangedTest001, Function | MediumTest | Level3)
553 {
554 EventFwk::MatchingSkills matchingSkills;
555 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
556 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
557 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
558 cellularDataHandler->Init();
559 cellularDataHandler->HandleImsCallChanged(1);
560 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr);
561 cellularDataHandler->HandleImsCallChanged(4);
562 EXPECT_NE(cellularDataHandler->incallDataStateMachine_, nullptr);
563 cellularDataHandler->HandleImsCallChanged(2);
564 EXPECT_NE(cellularDataHandler->incallDataStateMachine_->GetCallState(), 8);
565 cellularDataHandler->HandleImsCallChanged(4);
566 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 4);
567 cellularDataHandler->HandleImsCallChanged(6);
568 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 6);
569 cellularDataHandler->HandleImsCallChanged(8);
570 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 8);
571 }
572
573 /**
574 * @tc.number HandleSimAccountLoadedTest001
575 * @tc.name test error branch
576 * @tc.desc Function test
577 */
HWTEST_F(CellularDataHandlerTest, HandleSimAccountLoadedTest001, Function | MediumTest | Level3)578 HWTEST_F(CellularDataHandlerTest, HandleSimAccountLoadedTest001, Function | MediumTest | Level3)
579 {
580 EventFwk::MatchingSkills matchingSkills;
581 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
582 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
583 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
584 cellularDataHandler->Init();
585 cellularDataHandler->HandleSimAccountLoaded();
586 EXPECT_EQ(cellularDataHandler->isSimAccountLoaded_, false);
587 }
588
589 /**
590 * @tc.number PsDataRatChangedTest001
591 * @tc.name test error branch
592 * @tc.desc Function test
593 */
HWTEST_F(CellularDataHandlerTest, PsDataRatChangedTest001, Function | MediumTest | Level3)594 HWTEST_F(CellularDataHandlerTest, PsDataRatChangedTest001, Function | MediumTest | Level3)
595 {
596 EventFwk::MatchingSkills matchingSkills;
597 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
598 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
599 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
600 cellularDataHandler->Init();
601 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
602 cellularDataHandler->PsDataRatChanged(event);
603 cellularDataHandler->dataSwitchSettings_->userDataOn_ = false;
604 EXPECT_FALSE(cellularDataHandler->dataSwitchSettings_->IsUserDataOn());
605 }
606
607 /**
608 * @tc.number SetPolicyDataOnTest001
609 * @tc.name test error branch
610 * @tc.desc Function test
611 */
HWTEST_F(CellularDataHandlerTest, SetPolicyDataOnTest001, Function | MediumTest | Level3)612 HWTEST_F(CellularDataHandlerTest, SetPolicyDataOnTest001, Function | MediumTest | Level3)
613 {
614 EventFwk::MatchingSkills matchingSkills;
615 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
616 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
617 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
618 cellularDataHandler->Init();
619 cellularDataHandler->dataSwitchSettings_->policyDataOn_ = false;
620 cellularDataHandler->SetPolicyDataOn(true);
621 EXPECT_TRUE(cellularDataHandler->dataSwitchSettings_->IsUserDataOn());
622 cellularDataHandler->dataSwitchSettings_->policyDataOn_ = true;
623 cellularDataHandler->SetPolicyDataOn(false);
624 EXPECT_FALSE(cellularDataHandler->dataSwitchSettings_->policyDataOn_);
625 }
626
627 /**
628 * @tc.number SetRilAttachApnTest001
629 * @tc.name test error branch
630 * @tc.desc Function test
631 */
HWTEST_F(CellularDataHandlerTest, SetRilAttachApnTest001, Function | MediumTest | Level3)632 HWTEST_F(CellularDataHandlerTest, SetRilAttachApnTest001, Function | MediumTest | Level3)
633 {
634 EventFwk::MatchingSkills matchingSkills;
635 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
636 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
637 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
638 cellularDataHandler->Init();
639 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
640 sptr<ApnItem> attachApn = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
641 cellularDataHandler->apnManager_->allApnItem_.push_back(attachApn);
642 cellularDataHandler->SetRilAttachApn();
643 }
644
645 /**
646 * @tc.number HasAnyHigherPriorityConnectionTest001
647 * @tc.name test error branch
648 * @tc.desc Function test
649 */
HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest001, Function | MediumTest | Level3)650 HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest001, Function | MediumTest | Level3)
651 {
652 EventFwk::MatchingSkills matchingSkills;
653 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
654 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
655 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
656 cellularDataHandler->Init();
657 sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
658 sortApnHolder->priority_ = 1;
659 sortApnHolder->dataCallEnabled_ = true;
660 sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_CONNECTED;
661 cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder);
662 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
663 apnHolder->priority_ = 0;
664 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
665 EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true);
666 EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder));
667 }
668
669 /**
670 * @tc.number HasAnyHigherPriorityConnectionTest002
671 * @tc.name test error branch
672 * @tc.desc Function test
673 */
HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest002, Function | MediumTest | Level3)674 HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest002, Function | MediumTest | Level3)
675 {
676 EventFwk::MatchingSkills matchingSkills;
677 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
678 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
679 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
680 cellularDataHandler->Init();
681 sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
682 sortApnHolder->priority_ = 1;
683 sortApnHolder->dataCallEnabled_ = true;
684 sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_CONNECTING;
685 cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder);
686 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
687 apnHolder->priority_ = 0;
688 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
689 EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true);
690 EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder));
691 }
692
693 /**
694 * @tc.number HasAnyHigherPriorityConnectionTest003
695 * @tc.name test error branch
696 * @tc.desc Function test
697 */
HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest003, Function | MediumTest | Level3)698 HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest003, Function | MediumTest | Level3)
699 {
700 EventFwk::MatchingSkills matchingSkills;
701 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
702 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
703 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
704 cellularDataHandler->Init();
705 sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
706 sortApnHolder->priority_ = 1;
707 sortApnHolder->dataCallEnabled_ = true;
708 sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_DISCONNECTING;
709 cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder);
710 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
711 apnHolder->priority_ = 0;
712 EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
713 EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true);
714 EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder));
715 }
716
717 /**
718 * @tc.number HasInternetCapabilityTest001
719 * @tc.name test error branch
720 * @tc.desc Function test
721 */
HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest001, Function | MediumTest | Level3)722 HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest001, Function | MediumTest | Level3)
723 {
724 EventFwk::MatchingSkills matchingSkills;
725 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
726 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
727 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
728 cellularDataHandler->Init();
729 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release();
730 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
731 connectionManager, nullptr);
732 cellularMachine->capability_ = NetCap::NET_CAPABILITY_INTERNET;
733 cellularDataHandler->connectionManager_->cidActiveConnectionMap_[0] = cellularMachine;
734 EXPECT_NE(cellularDataHandler->connectionManager_->GetActiveConnectionByCid(0), nullptr);
735 EXPECT_TRUE(cellularDataHandler->HasInternetCapability(0));
736 }
737
738 /**
739 * @tc.number HasInternetCapabilityTest002
740 * @tc.name test error branch
741 * @tc.desc Function test
742 */
HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest002, Function | MediumTest | Level3)743 HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest002, Function | MediumTest | Level3)
744 {
745 EventFwk::MatchingSkills matchingSkills;
746 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
747 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
748 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
749 cellularDataHandler->Init();
750 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release();
751 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
752 connectionManager, nullptr);
753 cellularMachine->capability_ = NetCap::NET_CAPABILITY_MMS;
754 cellularDataHandler->connectionManager_->cidActiveConnectionMap_[0] = cellularMachine;
755 EXPECT_NE(cellularDataHandler->connectionManager_->GetActiveConnectionByCid(0), nullptr);
756 EXPECT_FALSE(cellularDataHandler->HasInternetCapability(0));
757 }
758
759 /**
760 * @tc.number ChangeConnectionForDsdsTest001
761 * @tc.name test error branch
762 * @tc.desc Function test
763 */
HWTEST_F(CellularDataHandlerTest, ChangeConnectionForDsdsTest001, Function | MediumTest | Level3)764 HWTEST_F(CellularDataHandlerTest, ChangeConnectionForDsdsTest001, Function | MediumTest | Level3)
765 {
766 EventFwk::MatchingSkills matchingSkills;
767 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
768 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
769 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
770 cellularDataHandler->Init();
771 cellularDataHandler->ChangeConnectionForDsds(true);
772 EXPECT_TRUE(cellularDataHandler->dataSwitchSettings_->internalDataOn_);
773 }
774
775 /**
776 * @tc.number GetDataConnApnAttrTest001
777 * @tc.name test error branch
778 * @tc.desc Function test
779 */
HWTEST_F(CellularDataHandlerTest, GetDataConnApnAttrTest001, Function | MediumTest | Level3)780 HWTEST_F(CellularDataHandlerTest, GetDataConnApnAttrTest001, Function | MediumTest | Level3)
781 {
782 EventFwk::MatchingSkills matchingSkills;
783 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
784 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
785 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
786 cellularDataHandler->Init();
787 sptr<ApnHolder> apnHolder1 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
788 apnHolder1->apnItem_ = nullptr;
789 apnHolder1->dataCallEnabled_ = true;
790 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder1);
791 sptr<ApnHolder> apnHolder2 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
792 sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
793 apnItem->attr_.isEdited_ = true;
794 apnHolder2->apnItem_ = apnItem;
795 apnHolder2->dataCallEnabled_ = true;
796 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder2);
797 ApnItem::Attribute apnAttr;
798 apnAttr.isEdited_ = false;
799 cellularDataHandler->GetDataConnApnAttr(apnAttr);
800 EXPECT_TRUE(apnAttr.isEdited_);
801 }
802
803 /**
804 * @tc.number GetDataConnIpTypeTest001
805 * @tc.name test error branch
806 * @tc.desc Function test
807 */
HWTEST_F(CellularDataHandlerTest, GetDataConnIpTypeTest001, Function | MediumTest | Level3)808 HWTEST_F(CellularDataHandlerTest, GetDataConnIpTypeTest001, Function | MediumTest | Level3)
809 {
810 EventFwk::MatchingSkills matchingSkills;
811 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
812 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
813 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
814 cellularDataHandler->Init();
815 sptr<ApnHolder> apnHolder1 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
816 apnHolder1->cellularDataStateMachine_ = nullptr;
817 apnHolder1->dataCallEnabled_ = true;
818 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder1);
819 sptr<ApnHolder> apnHolder2 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
820 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release();
821 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
822 connectionManager, nullptr);
823 cellularMachine->ipType_ = "IPV4";
824 apnHolder2->cellularDataStateMachine_ = cellularMachine;
825 apnHolder2->dataCallEnabled_ = true;
826 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder2);
827 cellularDataHandler->GetDataConnIpType();
828 EXPECT_EQ(cellularDataHandler->GetDataConnIpType(), "IPV4");
829 }
830
831 /**
832 * @tc.number CheckForCompatibleDataConnectionTest001
833 * @tc.name test error branch
834 * @tc.desc Function test
835 */
HWTEST_F(CellularDataHandlerTest, CheckForCompatibleDataConnectionTest001, Function | MediumTest | Level3)836 HWTEST_F(CellularDataHandlerTest, CheckForCompatibleDataConnectionTest001, Function | MediumTest | Level3)
837 {
838 EventFwk::MatchingSkills matchingSkills;
839 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
840 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
841 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1);
842 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
843 apnHolder->apnType_ = DATA_CONTEXT_ROLE_DUN;
844 EXPECT_EQ(cellularDataHandler->CheckForCompatibleDataConnection(apnHolder), nullptr);
845 cellularDataHandler->Init();
846 EXPECT_EQ(cellularDataHandler->CheckForCompatibleDataConnection(apnHolder), nullptr);
847 }
848
849 /**
850 * @tc.number ReleaseCellularDataConnectionTest001
851 * @tc.name test error branch
852 * @tc.desc Function test
853 */
HWTEST_F(CellularDataHandlerTest, ReleaseCellularDataConnectionTest001, Function | MediumTest | Level3)854 HWTEST_F(CellularDataHandlerTest, ReleaseCellularDataConnectionTest001, Function | MediumTest | Level3)
855 {
856 EventFwk::MatchingSkills matchingSkills;
857 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
858 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
859 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
860 cellularDataHandler->Init();
861 std::set<uint32_t> reqUids = {1};
862 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
863 apnHolder->reqUids_ = reqUids;
864 cellularDataHandler->apnManager_->apnIdApnHolderMap_[1] = apnHolder;
865 cellularDataHandler->ReleaseCellularDataConnection();
866 EXPECT_NE(cellularDataHandler->apnManager_->apnIdApnHolderMap_[1]->apnState_, 3);
867 }
868
869 /**
870 * @tc.number UpdateNetworkInfo_001
871 * @tc.name test error branch
872 * @tc.desc Function test
873 */
HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_001, Function | MediumTest | Level3)874 HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_001, Function | MediumTest | Level3)
875 {
876 EventFwk::MatchingSkills matchingSkills;
877 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
878 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
879 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
880 EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr);
881 EXPECT_FALSE(cellularDataHandler->UpdateNetworkInfo());
882 }
883
884 /**
885 * @tc.number UpdateNetworkInfo_002
886 * @tc.name test error branch
887 * @tc.desc Function test
888 */
HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_002, Function | MediumTest | Level3)889 HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_002, Function | MediumTest | Level3)
890 {
891 EventFwk::MatchingSkills matchingSkills;
892 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
893 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
894 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0);
895 cellularDataHandler->Init();
896 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
897 EXPECT_TRUE(cellularDataHandler->UpdateNetworkInfo());
898 }
899 } // namespace Telephony
900 } // namespace OHOS