1 /*
2 * Copyright (C) 2022 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 #include "activating.h"
18 #include "active.h"
19 #include "apn_holder.h"
20 #include "apn_item.h"
21 #include "apn_manager.h"
22 #include "cellular_data_client.h"
23 #include "cellular_data_constant.h"
24 #include "cellular_data_controller.h"
25 #include "cellular_data_dump_helper.h"
26 #include "cellular_data_error.h"
27 #include "cellular_data_handler.h"
28 #include "cellular_data_hisysevent.h"
29 #include "cellular_data_rdb_observer.h"
30 #include "cellular_data_roaming_observer.h"
31 #include "cellular_data_service.h"
32 #include "cellular_data_manager_stub.h"
33 #include "cellular_data_setting_observer.h"
34 #include "cellular_data_settings_rdb_helper.h"
35 #include "cellular_data_state_machine.h"
36 #include "cellular_data_utils.h"
37 #include "common_event_manager.h"
38 #include "common_event_support.h"
39 #include "core_service_client.h"
40 #include "data_access_token.h"
41 #include "data_connection_manager.h"
42 #include "data_connection_monitor.h"
43 #include "datashare_result_set.h"
44 #include "default.h"
45 #include "disconnecting.h"
46 #include "gtest/gtest.h"
47 #include "inactive.h"
48 #include "incall_data_state_machine.h"
49 #include "net_manager_call_back.h"
50 #include "net_manager_tactics_call_back.h"
51 #include "network_search_callback.h"
52 #include "pdp_profile_data.h"
53 #include "state_notification.h"
54 #include "telephony_errors.h"
55 #include "telephony_hisysevent.h"
56 #include "telephony_log_wrapper.h"
57 #include "uri.h"
58 #include "apn_attribute.h"
59 #include "icellular_data_manager.h"
60
61 namespace OHOS {
62 namespace Telephony {
63 using namespace testing::ext;
64
65 namespace {
66 const int32_t INVALID_SLOTID = -1;
67 const int32_t INVALID_SLOTID_TWO = 5;
68 const int32_t INVALID_CID = -1;
69 const int32_t INVALID_FD = -1;
70 const int32_t SLEEP_TIME_SECONDS = 3;
71 const std::string ADDRESS = "127.0.0.1";
72 const std::string FLAG = ".";
73 } // namespace
74
75 class DemoHandler : public AppExecFwk::EventHandler {
76 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & runner)77 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &runner) : AppExecFwk::EventHandler(runner) {}
~DemoHandler()78 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)79 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
80 };
81
82 class BranchTest : public testing::Test {
83 public:
84 static void SetUpTestCase();
85 static void TearDownTestCase();
86 void SetUp();
87 void TearDown();
88 };
SetUpTestCase()89 void BranchTest::SetUpTestCase() {}
90
TearDownTestCase()91 void BranchTest::TearDownTestCase() {}
92
SetUp()93 void BranchTest::SetUp() {}
94
TearDown()95 void BranchTest::TearDown() {}
96
97 class StateMachineTest : public TelEventHandler {
98 public:
StateMachineTest()99 StateMachineTest() : TelEventHandler("StateMachineTest") {}
100 ~StateMachineTest() = default;
101 std::shared_ptr<CellularDataStateMachine> CreateCellularDataConnect(int32_t slotId);
102
103 public:
104 std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine_ = nullptr;
105 };
106
CreateCellularDataConnect(int32_t slotId)107 std::shared_ptr<CellularDataStateMachine> StateMachineTest::CreateCellularDataConnect(int32_t slotId)
108 {
109 if (cellularDataStateMachine_ != nullptr) {
110 return cellularDataStateMachine_;
111 }
112 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(slotId).release();
113 if (connectionManager == nullptr) {
114 return nullptr;
115 }
116 connectionManager->Init();
117 cellularDataStateMachine_ = std::make_shared<CellularDataStateMachine>(
118 connectionManager, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
119 return cellularDataStateMachine_;
120 }
121
122 class IncallStateMachineTest : public TelEventHandler {
123 public:
IncallStateMachineTest()124 IncallStateMachineTest() : TelEventHandler("IncallStateMachineTest") {}
125 ~IncallStateMachineTest() = default;
126 std::shared_ptr<IncallDataStateMachine> CreateIncallDataStateMachine(int32_t slotId);
127
128 public:
129 std::shared_ptr<IncallDataStateMachine> incallStateMachine_ = nullptr;
130 };
131
CreateIncallDataStateMachine(int32_t slotId)132 std::shared_ptr<IncallDataStateMachine> IncallStateMachineTest::CreateIncallDataStateMachine(int32_t slotId)
133 {
134 if (incallStateMachine_ != nullptr) {
135 return incallStateMachine_;
136 }
137 sptr<ApnManager> apnManager = std::make_unique<ApnManager>().release();
138 if (apnManager == nullptr) {
139 return nullptr;
140 }
141 incallStateMachine_ = std::make_shared<IncallDataStateMachine>(slotId,
142 std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())), apnManager);
143 return incallStateMachine_;
144 }
145
146 /**
147 * @tc.number Telephony_CellularDataHandler_001
148 * @tc.name test error branch
149 * @tc.desc Function test
150 */
151 HWTEST_F(BranchTest, Telephony_CellularDataHandler_001, Function | MediumTest | Level1)
152 {
153 EventFwk::MatchingSkills matchingSkills;
154 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
155 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
156 CellularDataHandler cellularDataHandler { subscriberInfo, 0 };
157 cellularDataHandler.HandleSimStateChanged();
158 cellularDataHandler.ReleaseAllNetworkRequest();
159 cellularDataHandler.CreateApnItem();
160 auto event = AppExecFwk::InnerEvent::Get(0);
161 event = nullptr;
162 cellularDataHandler.ProcessEvent(event);
163 EventFwk::CommonEventData data;
164 cellularDataHandler.OnReceiveEvent(data);
165 ASSERT_NE(cellularDataHandler.SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
166 bool dataEnaled = false;
167 cellularDataHandler.IsCellularDataEnabled(dataEnaled);
168 ASSERT_FALSE(dataEnaled);
169 bool dataRoamingEnabled = false;
170 cellularDataHandler.IsCellularDataRoamingEnabled(dataRoamingEnabled);
171 ASSERT_FALSE(dataRoamingEnabled);
172 ASSERT_NE(cellularDataHandler.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
173 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState());
174 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState(""));
175 sptr<ApnHolder> apnHolder;
176 DisConnectionReason reason = cellularDataHandler.GetDisConnectionReason();
177 cellularDataHandler.ClearConnection(apnHolder, reason);
178 cellularDataHandler.EstablishAllApnsIfConnectable();
179 cellularDataHandler.ClearAllConnections(reason);
180 cellularDataHandler.GetSlotId();
181 ASSERT_FALSE(cellularDataHandler.HandleApnChanged());
182 cellularDataHandler.HandleApnChanged(event);
183 cellularDataHandler.GetCellularDataFlowType();
184 cellularDataHandler.SetPolicyDataOn(true);
185 ASSERT_FALSE(cellularDataHandler.IsRestrictedMode());
186 cellularDataHandler.GetDisConnectionReason();
187 ASSERT_FALSE(cellularDataHandler.HasInternetCapability(0));
188 ASSERT_EQ(nullptr, cellularDataHandler.FindIdleCellularDataConnection());
189 cellularDataHandler.AttemptEstablishDataConnection(apnHolder);
190 cellularDataHandler.airplaneObserver_ = nullptr;
191 cellularDataHandler.AttemptEstablishDataConnection(apnHolder);
192 ASSERT_FALSE(cellularDataHandler.CheckAttachAndSimState(apnHolder));
193 ASSERT_FALSE(cellularDataHandler.CheckRoamingState(apnHolder));
194 ASSERT_FALSE(cellularDataHandler.CheckApnState(apnHolder));
195 cellularDataHandler.RemoveAllEvents();
196 sleep(SLEEP_TIME_SECONDS);
197 }
198
199 /**
200 * @tc.number Telephony_CellularDataHandler_002
201 * @tc.name test error branch
202 * @tc.desc Function test
203 */
204 HWTEST_F(BranchTest, Telephony_CellularDataHandler_002, Function | MediumTest | Level1)
205 {
206 EventFwk::MatchingSkills matchingSkills;
207 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
208 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
209 CellularDataHandler cellularDataHandler { subscriberInfo, 0 };
210 auto event = AppExecFwk::InnerEvent::Get(0);
211 event = nullptr;
212 sptr<ApnHolder> apnHolder;
213 ApnItem::Attribute apnAttr;
214 cellularDataHandler.RadioPsConnectionAttached(event);
215 cellularDataHandler.RoamingStateOn(event);
216 cellularDataHandler.RoamingStateOff(event);
217 cellularDataHandler.EstablishDataConnectionComplete(event);
218 cellularDataHandler.DisconnectDataComplete(event);
219 cellularDataHandler.MsgEstablishDataConnection(event);
220 cellularDataHandler.MsgRequestNetwork(event);
221 cellularDataHandler.HandleSettingSwitchChanged(event);
222 cellularDataHandler.HandleDBSettingIncallChanged(event);
223 cellularDataHandler.HandleDefaultDataSubscriptionChanged();
224 cellularDataHandler.IncallDataComplete(event);
225 cellularDataHandler.HandleCallChanged(0);
226 cellularDataHandler.HandleImsCallChanged(0);
227 cellularDataHandler.HandleVoiceCallChanged(0);
228 cellularDataHandler.HandleSimEvent(event);
229 cellularDataHandler.HandleSimAccountLoaded();
230 cellularDataHandler.HandleRadioStateChanged(event);
231 cellularDataHandler.HandleDsdsModeChanged(event);
232 cellularDataHandler.SetRilAttachApnResponse(event);
233 cellularDataHandler.GetDefaultConfiguration();
234 cellularDataHandler.GetDefaultDataRoamingConfig();
235 cellularDataHandler.HandleRadioNrStateChanged(event);
236 cellularDataHandler.HandleRadioNrFrequencyChanged(event);
237 cellularDataHandler.HandleDBSettingEnableChanged(event);
238 cellularDataHandler.HandleDBSettingRoamingChanged(event);
239 cellularDataHandler.SetDataPermittedResponse(event);
240 cellularDataHandler.OnRilAdapterHostDied(event);
241 cellularDataHandler.OnCleanAllDataConnectionsDone(event);
242 cellularDataHandler.RegisterDataSettingObserver();
243 cellularDataHandler.UnRegisterDataSettingObserver();
244 cellularDataHandler.GetDataConnApnAttr(apnAttr);
245 cellularDataHandler.HandleFactoryReset(event);
246 cellularDataHandler.airplaneObserver_ = nullptr;
247 cellularDataHandler.RegisterDataSettingObserver();
248 cellularDataHandler.UnRegisterDataSettingObserver();
249 ASSERT_FALSE(cellularDataHandler.HasAnyHigherPriorityConnection(apnHolder));
250 cellularDataHandler.RemoveAllEvents();
251 sleep(SLEEP_TIME_SECONDS);
252 }
253
254 /**
255 * @tc.number Telephony_CellularDataHandler_003
256 * @tc.name test error branch
257 * @tc.desc Function test
258 */
259 HWTEST_F(BranchTest, Telephony_CellularDataHandler_003, Function | MediumTest | Level3)
260 {
261 EventFwk::MatchingSkills matchingSkills;
262 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
263 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
264 CellularDataHandler cellularDataHandler { subscriberInfo, INVALID_SLOTID };
265 cellularDataHandler.apnManager_ = std::make_unique<ApnManager>().release();
266 cellularDataHandler.SetDataPermittedForMms(false);
267 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
268 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
269 cellularDataHandler.ClearConnection(apnHolder, reason);
270 cellularDataHandler.EstablishAllApnsIfConnectable();
271 cellularDataHandler.ClearAllConnections(reason);
272 cellularDataHandler.ChangeConnectionForDsds(false);
273 cellularDataHandler.ChangeConnectionForDsds(true);
274 cellularDataHandler.connectionManager_ = std::make_unique<DataConnectionManager>(INVALID_SLOTID).release();
275 cellularDataHandler.ClearAllConnections(reason);
276 cellularDataHandler.EstablishAllApnsIfConnectable();
277 cellularDataHandler.UpdatePhysicalConnectionState(true);
278 cellularDataHandler.ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
279 ASSERT_FALSE(cellularDataHandler.CheckApnState(apnHolder));
280 cellularDataHandler.AttemptEstablishDataConnection(apnHolder);
281 cellularDataHandler.connectionManager_ = nullptr;
282 auto event = AppExecFwk::InnerEvent::Get(0);
283 cellularDataHandler.HandleUpdateNetInfo(event);
284 cellularDataHandler.ClearConnectionIfRequired();
285 event = nullptr;
286 cellularDataHandler.MsgEstablishDataConnection(event);
287 ASSERT_FALSE(cellularDataHandler.HasAnyHigherPriorityConnection(apnHolder));
288 cellularDataHandler.connectionManager_ = std::make_unique<DataConnectionManager>(INVALID_SLOTID).release();
289 ASSERT_FALSE(cellularDataHandler.HasInternetCapability(INVALID_CID));
290 ASSERT_EQ(cellularDataHandler.GetDataRecoveryState(), 0);
291 cellularDataHandler.DisconnectDataComplete(event);
292 std::string str = "";
293 ASSERT_EQ(cellularDataHandler.GetDataConnIpType(), str);
294 cellularDataHandler.apnManager_ = nullptr;
295 ASSERT_EQ(cellularDataHandler.GetDataConnIpType(), str);
296 cellularDataHandler.CheckForCompatibleDataConnection(apnHolder);
297 event = AppExecFwk::InnerEvent::Get(0);
298 cellularDataHandler.HandleDBSettingRoamingChanged(event);
299 cellularDataHandler.ClearConnectionIfRequired();
300 ASSERT_EQ(nullptr, cellularDataHandler.FindIdleCellularDataConnection());
301 cellularDataHandler.RemoveAllEvents();
302 sleep(SLEEP_TIME_SECONDS);
303 }
304
305 /**
306 * @tc.number Telephony_CellularDataHandler_004
307 * @tc.name test error branch
308 * @tc.desc Function test
309 */
310 HWTEST_F(BranchTest, Telephony_CellularDataHandler_004, Function | MediumTest | Level1)
311 {
312 CellularDataController controller { 0 };
313 controller.Init();
314 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
315 auto event = AppExecFwk::InnerEvent::Get(0);
316 event = nullptr;
317 controller.cellularDataHandler_->ProcessEvent(event);
318 controller.cellularDataHandler_->PsDataRatChanged(event);
319 ApnItem::Attribute apnAttr;
320 controller.cellularDataHandler_->GetDataConnApnAttr(apnAttr);
321 EventFwk::CommonEventData data;
322 controller.cellularDataHandler_->OnReceiveEvent(data);
323 ASSERT_EQ(controller.cellularDataHandler_->SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
324 bool dataEnaled = false;
325 controller.cellularDataHandler_->IsCellularDataEnabled(dataEnaled);
326 bool dataRoamingEnabled = false;
327 controller.cellularDataHandler_->IsCellularDataRoamingEnabled(dataRoamingEnabled);
328 ASSERT_NE(controller.cellularDataHandler_->SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
329 controller.cellularDataHandler_->CreateCellularDataConnect();
330 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, controller.cellularDataHandler_->GetCellularDataState());
331 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, controller.cellularDataHandler_->GetCellularDataState(""));
332 sptr<ApnHolder> apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
333 DisConnectionReason reason = controller.cellularDataHandler_->GetDisConnectionReason();
334 controller.cellularDataHandler_->ClearConnection(apnHolder, reason);
335 controller.cellularDataHandler_->EstablishAllApnsIfConnectable();
336 controller.cellularDataHandler_->ClearAllConnections(reason);
337 controller.cellularDataHandler_->GetSlotId();
338 ASSERT_TRUE(controller.cellularDataHandler_->HandleApnChanged());
339 controller.cellularDataHandler_->HandleApnChanged(event);
340 controller.cellularDataHandler_->GetCellularDataFlowType();
341 controller.cellularDataHandler_->SetPolicyDataOn(true);
342 ASSERT_FALSE(controller.cellularDataHandler_->IsRestrictedMode());
343 controller.cellularDataHandler_->GetDisConnectionReason();
344 ASSERT_FALSE(controller.cellularDataHandler_->HasInternetCapability(0));
345 ASSERT_EQ(nullptr, controller.cellularDataHandler_->FindIdleCellularDataConnection());
346 controller.cellularDataHandler_->AttemptEstablishDataConnection(apnHolder);
347 controller.cellularDataHandler_->EstablishDataConnection(apnHolder, 1);
348 controller.cellularDataHandler_->CheckRoamingState(apnHolder);
349 controller.cellularDataHandler_->CheckApnState(apnHolder);
350 ASSERT_FALSE(controller.cellularDataHandler_->CheckAttachAndSimState(apnHolder));
351 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
352 controller.cellularDataHandler_->RemoveAllEvents();
353 sleep(SLEEP_TIME_SECONDS);
354 }
355
356 /**
357 * @tc.number Telephony_CellularDataHandler_005
358 * @tc.name test error branch
359 * @tc.desc Function test
360 */
361 HWTEST_F(BranchTest, Telephony_CellularDataHandler_005, Function | MediumTest | Level1)
362 {
363 CellularDataController controller { 0 };
364 controller.Init();
365 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
366 auto event = AppExecFwk::InnerEvent::Get(0);
367 controller.cellularDataHandler_->RadioPsConnectionAttached(event);
368 controller.cellularDataHandler_->RoamingStateOn(event);
369 controller.cellularDataHandler_->RoamingStateOff(event);
370 controller.cellularDataHandler_->MsgEstablishDataConnection(event);
371 controller.cellularDataHandler_->MsgRequestNetwork(event);
372 controller.cellularDataHandler_->HandleSettingSwitchChanged(event);
373 controller.cellularDataHandler_->HandleDBSettingIncallChanged(event);
374 controller.cellularDataHandler_->HandleDefaultDataSubscriptionChanged();
375 controller.cellularDataHandler_->IncallDataComplete(event);
376 controller.cellularDataHandler_->HandleCallChanged(0);
377 controller.cellularDataHandler_->HandleImsCallChanged(0);
378 controller.cellularDataHandler_->HandleVoiceCallChanged(0);
379 controller.cellularDataHandler_->HandleSimEvent(event);
380 controller.cellularDataHandler_->HandleSimAccountLoaded();
381 controller.cellularDataHandler_->HandleRadioStateChanged(event);
382 controller.cellularDataHandler_->HandleDsdsModeChanged(event);
383 controller.cellularDataHandler_->SetRilAttachApnResponse(event);
384 controller.cellularDataHandler_->GetDefaultConfiguration();
385 controller.cellularDataHandler_->HandleRadioNrStateChanged(event);
386 controller.cellularDataHandler_->HandleRadioNrFrequencyChanged(event);
387 controller.cellularDataHandler_->HandleDBSettingEnableChanged(event);
388 controller.cellularDataHandler_->HandleDBSettingRoamingChanged(event);
389 controller.cellularDataHandler_->SetDataPermittedResponse(event);
390 controller.cellularDataHandler_->OnRilAdapterHostDied(event);
391 controller.cellularDataHandler_->OnCleanAllDataConnectionsDone(event);
392 controller.cellularDataHandler_->HandleFactoryReset(event);
393 controller.cellularDataHandler_->PsDataRatChanged(event);
394 sptr<ApnHolder> apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
395 ASSERT_FALSE(controller.cellularDataHandler_->HasAnyHigherPriorityConnection(apnHolder));
396 auto dataInfo = std::make_shared<DataProfileDataInfo>();
397 ASSERT_FALSE(controller.cellularDataHandler_->HasAnyHigherPriorityConnection(apnHolder));
398 auto netInfo = std::make_shared<SetupDataCallResultInfo>();
399 auto event3 = AppExecFwk::InnerEvent::Get(0, netInfo);
400 controller.cellularDataHandler_->apnManager_ = nullptr;
401 controller.cellularDataHandler_->EstablishDataConnectionComplete(event3);
402 ASSERT_FALSE(controller.cellularDataHandler_->HasAnyHigherPriorityConnection(apnHolder));
403 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
404 controller.cellularDataHandler_->RemoveAllEvents();
405 sleep(SLEEP_TIME_SECONDS);
406 }
407
408 /**
409 * @tc.number Telephony_CellularDataHandler_006
410 * @tc.name test error branch
411 * @tc.desc Function test
412 */
413 HWTEST_F(BranchTest, Telephony_CellularDataHandler_006, Function | MediumTest | Level3)
414 {
415 EventFwk::MatchingSkills matchingSkills;
416 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
417 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
418 CellularDataHandler cellularDataHandler { subscriberInfo, 0 };
419 auto event = AppExecFwk::InnerEvent::Get(0);
420 event = nullptr;
421 cellularDataHandler.apnManager_ = std::make_unique<ApnManager>().release();
422 sptr<ApnHolder> apnHolder;
423 std::string str = "";
424 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState());
425 cellularDataHandler.CheckForCompatibleDataConnection(apnHolder);
426 cellularDataHandler.PsRadioEmergencyStateOpen(event);
427 cellularDataHandler.PsRadioEmergencyStateClose(event);
428 cellularDataHandler.IsNeedDoRecovery(true);
429 cellularDataHandler.HandleSortConnection();
430 ASSERT_EQ(cellularDataHandler.IsSingleConnectionEnabled(1), true);
431 ASSERT_EQ(cellularDataHandler.GetDataConnIpType(), str);
432 ASSERT_EQ(cellularDataHandler.GetDataRecoveryState(), -1);
433 ASSERT_FALSE(cellularDataHandler.IsGsm());
434 ASSERT_FALSE(cellularDataHandler.IsCdma());
435 cellularDataHandler.lastCallState_ = 0;
436 cellularDataHandler.HandleCallChanged(0);
437 cellularDataHandler.dataSwitchSettings_ = nullptr;
438 ASSERT_NE(cellularDataHandler.SetIntelligenceSwitchEnable(true), TELEPHONY_ERR_SUCCESS);
439 cellularDataHandler.RemoveAllEvents();
440 sleep(SLEEP_TIME_SECONDS);
441 }
442
443 /**
444 * @tc.number Telephony_CellularDataHandler_007
445 * @tc.name test error branch
446 * @tc.desc Function test
447 */
448 HWTEST_F(BranchTest, Telephony_CellularDataHandler_007, Function | MediumTest | Level1)
449 {
450 CellularDataController controller { 0 };
451 controller.Init();
452 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
453 auto event = AppExecFwk::InnerEvent::Get(0);
454 sptr<ApnHolder> apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
455 std::string str = "";
456 controller.cellularDataHandler_->CheckForCompatibleDataConnection(apnHolder);
457 controller.cellularDataHandler_->HandleUpdateNetInfo(event);
458 controller.cellularDataHandler_->PsRadioEmergencyStateOpen(event);
459 controller.cellularDataHandler_->PsRadioEmergencyStateClose(event);
460 controller.cellularDataHandler_->IsNeedDoRecovery(true);
461 controller.cellularDataHandler_->CreateIncallDataStateMachine(1);
462 controller.cellularDataHandler_->HandleSettingSwitchChanged(event);
463 ASSERT_TRUE(controller.cellularDataHandler_->SetDataPermittedForMms(true));
464 controller.cellularDataHandler_->IncallDataComplete(event);
465 controller.cellularDataHandler_->HandleImsCallChanged(0);
466 controller.cellularDataHandler_->HandleSortConnection();
467 ASSERT_EQ(controller.cellularDataHandler_->IsSingleConnectionEnabled(1), false);
468 ASSERT_EQ(controller.cellularDataHandler_->GetDataConnIpType(), str);
469 ASSERT_NE(controller.cellularDataHandler_->GetDataRecoveryState(), -1);
470 ASSERT_FALSE(controller.cellularDataHandler_->IsGsm());
471 ASSERT_FALSE(controller.cellularDataHandler_->IsCdma());
472 ASSERT_EQ(controller.cellularDataHandler_->SetIntelligenceSwitchEnable(true), TELEPHONY_ERR_SUCCESS);
473 controller.cellularDataHandler_->ClearConnectionIfRequired();
474 controller.cellularDataHandler_->RemoveAllEvents();
475 sleep(SLEEP_TIME_SECONDS);
476 }
477
478 /**
479 * @tc.number Telephony_CellularDataHandler_008
480 * @tc.name test error branch
481 * @tc.desc Function test
482 */
483 HWTEST_F(BranchTest, Telephony_CellularDataHandler_008, Function | MediumTest | Level1)
484 {
485 CellularDataController controller{0};
486 controller.Init();
487 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
488 ASSERT_FALSE(controller.cellularDataHandler_->dataSwitchSettings_->IsUserDataRoamingOn());
489 int32_t result = controller.SetCellularDataRoamingEnabled(true);
490 std::cout << "SetCellularDataRoamingEnabled result: " << result << std::endl;
491 ASSERT_NE(result, TELEPHONY_ERR_SUCCESS);
492 ASSERT_FALSE(controller.cellularDataHandler_->dataSwitchSettings_->IsUserDataRoamingOn());
493
494 controller.cellularDataHandler_->dataSwitchSettings_->SetUserDataOn(false);
495 ASSERT_FALSE(controller.cellularDataHandler_->dataSwitchSettings_->IsUserDataOn());
496 controller.cellularDataHandler_->ResetDataFlowType();
497 controller.cellularDataHandler_->dataSwitchSettings_->SetUserDataOn(true);
498 controller.cellularDataHandler_->ResetDataFlowType();
499 ASSERT_TRUE(controller.cellularDataHandler_->dataSwitchSettings_->IsUserDataOn());
500 }
501
502 /**
503 * @tc.number Telephony_CellularDataHandler_009
504 * @tc.name test error branch
505 * @tc.desc Function test
506 */
507 HWTEST_F(BranchTest, Telephony_CellularDataHandler_009, Function | MediumTest | Level1)
508 {
509 CellularDataController controller{0};
510 controller.Init();
511 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
512 NetRequest request { 1, "simId1" };
513
514 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
515 std::shared_ptr<CellularDataStateMachine> stateMachine = machine->CreateCellularDataConnect(0);
516 sptr<ApnHolder> apn = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
517 ASSERT_FALSE(apn == nullptr);
518 apn->SetCellularDataStateMachine(stateMachine);
519 DisConnectionReason reason = controller.cellularDataHandler_->GetDisConnectionReason();
520 ASSERT_FALSE(apn->GetCellularDataStateMachine() == nullptr);
521 ASSERT_EQ(apn->GetApnState(), PROFILE_STATE_IDLE);
522 controller.cellularDataHandler_->ClearConnection(apn, reason);
523 ASSERT_FALSE(apn->GetCellularDataStateMachine() == nullptr);
524 apn->SetApnState(PROFILE_STATE_DISCONNECTING);
525 controller.cellularDataHandler_->ClearConnection(apn, reason);
526 ASSERT_FALSE(apn->GetCellularDataStateMachine() == nullptr);
527
528 apn->SetApnState(PROFILE_STATE_CONNECTED);
529 controller.cellularDataHandler_->ClearConnection(apn, reason);
530 ASSERT_EQ(apn->GetApnState(), PROFILE_STATE_DISCONNECTING);
531
532 apn->SetApnState(PROFILE_STATE_CONNECTED);
533 controller.cellularDataHandler_->ClearAllConnections(reason);
534 apn->SetApnState(PROFILE_STATE_CONNECTING);
535 controller.cellularDataHandler_->ClearAllConnections(reason);
536 ASSERT_EQ(apn->GetApnState(), PROFILE_STATE_DISCONNECTING);
537 }
538
539 /**
540 * @tc.number Telephony_CellularDataHandler_010
541 * @tc.name test error branch
542 * @tc.desc Function test
543 */
544 HWTEST_F(BranchTest, Telephony_CellularDataHandler_010, Function | MediumTest | Level1)
545 {
546 CellularDataController controller{0};
547 controller.Init();
548 sptr<ApnHolder> apn = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
549 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
550 std::shared_ptr<CellularDataStateMachine> stateMachine = machine->CreateCellularDataConnect(0);
551
552 auto event = AppExecFwk::InnerEvent::Get(0);
553 controller.cellularDataHandler_->RoamingStateOff(event);
554 controller.cellularDataHandler_->PsRadioEmergencyStateOpen(event);
555 apn->SetApnState(PROFILE_STATE_CONNECTED);
556 ASSERT_EQ(controller.cellularDataHandler_->GetCellularDataState(), PROFILE_STATE_CONNECTED);
557 controller.cellularDataHandler_->RoamingStateOff(event);
558 controller.cellularDataHandler_->PsRadioEmergencyStateOpen(event);
559 controller.cellularDataHandler_->PsRadioEmergencyStateClose(event);
560 apn->SetApnState(PROFILE_STATE_IDLE);
561 ASSERT_EQ(controller.cellularDataHandler_->GetCellularDataState(), PROFILE_STATE_IDLE);
562 controller.cellularDataHandler_->PsRadioEmergencyStateOpen(event);
563 controller.cellularDataHandler_->PsRadioEmergencyStateClose(event);
564 apn->SetApnState(PROFILE_STATE_DISCONNECTING);
565 ASSERT_EQ(controller.cellularDataHandler_->GetCellularDataState(), PROFILE_STATE_CONNECTED);
566 controller.cellularDataHandler_->PsRadioEmergencyStateOpen(event);
567 controller.cellularDataHandler_->PsRadioEmergencyStateClose(event);
568
569 sptr<ApnHolder> apn2 = controller.cellularDataHandler_->apnManager_->FindApnHolderById(2);
570 ASSERT_FALSE(apn2 == nullptr);
571 sptr<ApnHolder> apn3 = controller.cellularDataHandler_->apnManager_->FindApnHolderById(3);
572 ASSERT_FALSE(apn3 == nullptr);
573 apn->dataCallEnabled_ = true;
574 apn2->dataCallEnabled_ = true;
575 apn3->dataCallEnabled_ = true;
576 apn->SetApnState(PROFILE_STATE_IDLE);
577 apn2->SetApnState(PROFILE_STATE_IDLE);
578 apn3->SetApnState(PROFILE_STATE_FAILED);
579 apn3->SetCellularDataStateMachine(stateMachine);
580 ASSERT_EQ(controller.cellularDataHandler_->GetCellularDataState(), PROFILE_STATE_IDLE);
581 controller.cellularDataHandler_->PsRadioEmergencyStateClose(event);
582 ASSERT_EQ(apn3->GetApnState(), PROFILE_STATE_DISCONNECTING);
583
584 ASSERT_EQ(controller.cellularDataHandler_->GetCellularDataState("default"), PROFILE_STATE_IDLE);
585 }
586
587 /**
588 * @tc.number Telephony_CellularDataHandler_011
589 * @tc.name test error branch
590 * @tc.desc Function test
591 */
592 HWTEST_F(BranchTest, Telephony_CellularDataHandler_011, Function | MediumTest | Level1)
593 {
594 CellularDataController controller { 0 };
595 controller.Init();
596 controller.cellularDataHandler_->SendEstablishDataConnectionEvent(0);
597 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
598 int32_t reqType = TYPE_REQUEST_NET;
599 bool isMmsType = false;
600 controller.cellularDataHandler_->IsSimRequestNetOnVSimEnabled(reqType, isMmsType);
601 isMmsType = true;
602 controller.cellularDataHandler_->IsSimRequestNetOnVSimEnabled(reqType, isMmsType);
603 reqType = 0;
604 EXPECT_FALSE(controller.cellularDataHandler_->IsSimRequestNetOnVSimEnabled(reqType, isMmsType));
605 #endif
606 }
607
608 /**
609 * @tc.number Telephony_CellularDataHandler_012
610 * @tc.name test error branch
611 * @tc.desc Function test
612 */
613 HWTEST_F(BranchTest, Telephony_CellularDataHandler_012, Function | MediumTest | Level1)
614 {
615 CellularDataController controller { 0 };
616 controller.Init();
617 sptr<ApnHolder> apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
618 sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
619 apnHolder->SetCurrentApn(apnItem);
620 auto handler = controller.cellularDataHandler_;
621 handler->RetryOrClearConnection(nullptr, DisConnectionReason::REASON_CLEAR_CONNECTION, nullptr);
622 ASSERT_FALSE(handler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_SETUP_DATACALL));
623 handler->RetryOrClearConnection(apnHolder, DisConnectionReason::REASON_CLEAR_CONNECTION, nullptr);
624 ASSERT_FALSE(handler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_SETUP_DATACALL));
625 auto resultInfo = std::make_shared<SetupDataCallResultInfo>();
626 handler->RetryOrClearConnection(apnHolder, DisConnectionReason::REASON_CLEAR_CONNECTION, resultInfo);
627 ASSERT_FALSE(handler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_SETUP_DATACALL));
628 handler->RetryOrClearConnection(apnHolder, DisConnectionReason::REASON_RETRY_CONNECTION, resultInfo);
629 ASSERT_TRUE(handler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_SETUP_DATACALL));
630 handler->RetryOrClearConnection(apnHolder, DisConnectionReason::REASON_PERMANENT_REJECT, resultInfo);
631 ASSERT_TRUE(handler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_SETUP_DATACALL));
632 handler->apnManager_ = nullptr;
633 handler->RetryOrClearConnection(apnHolder, DisConnectionReason::REASON_PERMANENT_REJECT, resultInfo);
634 ASSERT_TRUE(handler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_SETUP_DATACALL));
635 }
636
637 /**
638 * @tc.number Telephony_CellularDataHandler_013
639 * @tc.name test error branch
640 * @tc.desc Function test
641 */
642 HWTEST_F(BranchTest, Telephony_CellularDataHandler_013, Function | MediumTest | Level1)
643 {
644 EventFwk::MatchingSkills matchingSkills;
645 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
646 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
647 CellularDataHandler cellularDataHandler { subscriberInfo, 0 };
648 auto event = AppExecFwk::InnerEvent::Get(-1);
649 cellularDataHandler.RetryToSetupDatacall(event);
650 ASSERT_FALSE(cellularDataHandler.HasInnerEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION));
651 event = nullptr;
652 cellularDataHandler.RetryToSetupDatacall(event);
653 ASSERT_FALSE(cellularDataHandler.HasInnerEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION));
654 auto event3 = AppExecFwk::InnerEvent::Get(1);
655 cellularDataHandler.RetryToSetupDatacall(event3);
656 ASSERT_FALSE(cellularDataHandler.HasInnerEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION));
657 }
658
659 /**
660 * @tc.number Telephony_CellularDataHandler_014
661 * @tc.name test error branch
662 * @tc.desc Function test
663 */
664 HWTEST_F(BranchTest, Telephony_CellularDataHandler_014, Function | MediumTest | Level1)
665 {
666 CellularDataController controller { 0 };
667 controller.Init();
668 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
669 auto event = AppExecFwk::InnerEvent::Get(0);
670 system::SetParameter("persist.edm.mobile_data_policy", "force_open");
671 controller.cellularDataHandler_->HandleDBSettingEnableChanged(event);
672 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
673 controller.cellularDataHandler_->RemoveAllEvents();
674 system::SetParameter("persist.edm.mobile_data_policy", "none");
675 sleep(SLEEP_TIME_SECONDS);
676 }
677
678 /**
679 * @tc.number Telephony_CellularDataHandler_015
680 * @tc.name test error branch
681 * @tc.desc Function test
682 */
683 HWTEST_F(BranchTest, Telephony_CellularDataHandler_015, Function | MediumTest | Level1)
684 {
685 CellularDataController controller { 0 };
686 controller.Init();
687 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
688 auto event = AppExecFwk::InnerEvent::Get(0);
689 system::SetParameter("persist.edm.mobile_data_policy", "disallow");
690 controller.cellularDataHandler_->HandleDBSettingEnableChanged(event);
691 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
692 controller.cellularDataHandler_->RemoveAllEvents();
693 system::SetParameter("persist.edm.mobile_data_policy", "none");
694 sleep(SLEEP_TIME_SECONDS);
695 }
696
697 /**
698 * @tc.number Telephony_CellularDataService_001
699 * @tc.name test error branch
700 * @tc.desc Function test
701 */
702 HWTEST_F(BranchTest, Telephony_CellularDataService_001, Function | MediumTest | Level3)
703 {
704 DataAccessToken token;
705 CellularDataService service;
706 std::vector<std::u16string> strV;
707 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
708 service.state_ = ServiceRunningState::STATE_RUNNING;
709 service.OnStart();
710 service.InitModule();
711 bool dataEnabled = false;
712 bool dataRoamingEnabled = false;
713 int32_t cellularDataState;
714 int32_t slotId;
715 int32_t capability;
716 int32_t type;
717 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataEnabled(dataEnabled));
718 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
719 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
720 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataState(cellularDataState));
721 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(INVALID_SLOTID, dataRoamingEnabled));
722 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(INVALID_SLOTID, false));
723 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(DEFAULT_SIM_SLOT_ID, dataRoamingEnabled));
724 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(DEFAULT_SIM_SLOT_ID, true));
725 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(INVALID_SLOTID));
726 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(DEFAULT_SIM_SLOT_ID));
727 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDefaultCellularDataSlotId(slotId));
728 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(INVALID_SLOTID));
729 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(DEFAULT_SIM_SLOT_ID));
730 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataFlowType(type));
731 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(INVALID_SLOTID, 0, capability));
732 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(DEFAULT_SIM_SLOT_ID, 0, capability));
733 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(INVALID_SLOTID));
734 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(DEFAULT_SIM_SLOT_ID));
735 int32_t reason = static_cast<int32_t>(DisConnectionReason::REASON_NORMAL);
736 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(INVALID_SLOTID, reason));
737 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(DEFAULT_SIM_SLOT_ID, reason));
738 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(INVALID_SLOTID, false));
739 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, false));
740 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, true));
741 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(INVALID_SLOTID, false));
742 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(DEFAULT_SIM_SLOT_ID, false));
743 NetRequest request;
744 request.ident = "simId12";
745 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.RequestNet(request));
746 request.ident = "simId2";
747 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ReleaseNet(request));
748 ASSERT_FALSE(service.GetCellularDataController(DEFAULT_SIM_SLOT_ID) != nullptr);
749 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID) != nullptr);
750 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID_TWO) != nullptr);
751 }
752
753 /**
754 * @tc.number Telephony_CellularDataService_002
755 * @tc.name test error branch
756 * @tc.desc Function test
757 */
758 HWTEST_F(BranchTest, Telephony_CellularDataService_002, Function | MediumTest | Level3)
759 {
760 CellularDataService service;
761 std::vector<std::u16string> strV;
762 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
763 service.state_ = ServiceRunningState::STATE_RUNNING;
764 service.OnStart();
765 service.InitModule();
766 bool dataEnabled = false;
767 bool dataRoamingEnabled = false;
768 int32_t cellularDataState;
769 int32_t state;
770 int32_t slotId;
771 int32_t capability;
772 int32_t type;
773 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataEnabled(dataEnabled));
774 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(false));
775 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(true));
776 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
777 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataState(cellularDataState));
778 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(INVALID_SLOTID, dataRoamingEnabled));
779 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(INVALID_SLOTID, false));
780 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(INVALID_SLOTID));
781 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDefaultCellularDataSlotId(slotId));
782 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(INVALID_SLOTID));
783 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataFlowType(type));
784 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(INVALID_SLOTID, 0, capability));
785 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(INVALID_SLOTID));
786 int32_t reason = static_cast<int32_t>(DisConnectionReason::REASON_NORMAL);
787 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(INVALID_SLOTID, reason));
788 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(INVALID_SLOTID, false));
789 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(INVALID_SLOTID, false));
790 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID) != nullptr);
791 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID_TWO) != nullptr);
792 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(DEFAULT_SIM_SLOT_ID, std::string(), state));
793 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(INVALID_SLOTID, std::string(), state));
794 ASSERT_EQ(service.GetDataRecoveryState(state), 0);
795 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(2));
796 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(INVALID_SLOTID));
797 service.GetFlowDataInfoDump();
798 service.OnStop();
799 }
800
801 /**
802 * @tc.number Telephony_CellularDataService_003
803 * @tc.name test error branch
804 * @tc.desc Function test
805 */
806 HWTEST_F(BranchTest, Telephony_CellularDataService_003, Function | MediumTest | Level3)
807 {
808 DataAccessToken token;
809 CellularDataService service;
810 std::vector<std::u16string> strV;
811 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
812 service.state_ = ServiceRunningState::STATE_RUNNING;
813 service.OnStart();
814 service.InitModule();
815 service.cellularDataControllers_.clear();
816 bool dataEnabled = false;
817 bool dataRoamingEnabled = false;
818 int32_t cellularDataState;
819 int32_t slotId;
820 int32_t capability;
821 int32_t type;
822 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataEnabled(dataEnabled));
823 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
824 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
825 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(INVALID_SLOTID, false));
826 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(DEFAULT_SIM_SLOT_ID, dataRoamingEnabled));
827 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(DEFAULT_SIM_SLOT_ID, true));
828 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataState(cellularDataState));
829 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(INVALID_SLOTID, dataRoamingEnabled));
830 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(INVALID_SLOTID));
831 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(DEFAULT_SIM_SLOT_ID));
832 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(INVALID_SLOTID));
833 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(DEFAULT_SIM_SLOT_ID));
834 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataFlowType(type));
835 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(INVALID_SLOTID, 0, capability));
836 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(DEFAULT_SIM_SLOT_ID, 0, capability));
837 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDefaultCellularDataSlotId(slotId));
838 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(INVALID_SLOTID, false));
839 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(DEFAULT_SIM_SLOT_ID, false));
840 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(INVALID_SLOTID));
841 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(DEFAULT_SIM_SLOT_ID));
842 int32_t reason = static_cast<int32_t>(DisConnectionReason::REASON_NORMAL);
843 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(INVALID_SLOTID, reason));
844 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(DEFAULT_SIM_SLOT_ID, reason));
845 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(INVALID_SLOTID, false));
846 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, false));
847 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, true));
848 NetRequest request;
849 request.ident = "simId12";
850 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.RequestNet(request));
851 request.ident = "simId2";
852 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ReleaseNet(request));
853 ASSERT_FALSE(service.GetCellularDataController(DEFAULT_SIM_SLOT_ID) != nullptr);
854 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID) != nullptr);
855 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID_TWO) != nullptr);
856 }
857
858 /**
859 * @tc.number Telephony_CellularDataService_004
860 * @tc.name test error branch
861 * @tc.desc Function test
862 */
863 HWTEST_F(BranchTest, Telephony_CellularDataService_004, Function | MediumTest | Level3)
864 {
865 DataAccessToken token;
866 CellularDataService service;
867 std::vector<std::u16string> strV;
868 int32_t state;
869 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
870 service.state_ = ServiceRunningState::STATE_RUNNING;
871 service.OnStart();
872 service.InitModule();
873 service.GetFlowDataInfoDump();
874 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(false));
875 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(true));
876 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(DEFAULT_SIM_SLOT_ID, std::string(), state));
877 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(INVALID_SLOTID, std::string(), state));
878 ASSERT_EQ(service.GetDataRecoveryState(state), 0);
879 ASSERT_EQ(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(2));
880 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(INVALID_SLOTID));
881 ApnAttribute apnAttr;
882 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(INVALID_SLOTID, apnAttr));
883 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(DEFAULT_SIM_SLOT_ID, apnAttr));
884 std::string ipType;
885 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(INVALID_SLOTID, ipType));
886 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(DEFAULT_SIM_SLOT_ID, ipType));
887 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(INVALID_SLOTID, true));
888 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(DEFAULT_SIM_SLOT_ID, true));
889 }
890
891 /**
892 * @tc.number Telephony_CellularDataService_005
893 * @tc.name test error branch
894 * @tc.desc Function test
895 */
896 HWTEST_F(BranchTest, Telephony_CellularDataService_005, Function | MediumTest | Level3)
897 {
898 DataAccessToken token;
899 CellularDataService service;
900 std::vector<std::u16string> strV;
901 int32_t state;
902 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
903 service.state_ = ServiceRunningState::STATE_RUNNING;
904 service.OnStart();
905 service.InitModule();
906 service.cellularDataControllers_.clear();
907 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(false));
908 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(true));
909 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(DEFAULT_SIM_SLOT_ID, std::string(), state));
910 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(INVALID_SLOTID, std::string(), state));
911 ASSERT_EQ(service.GetDataRecoveryState(state), 0);
912 ASSERT_EQ(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(2));
913 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(INVALID_SLOTID));
914 service.GetFlowDataInfoDump();
915 ApnAttribute apnAttr;
916 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(INVALID_SLOTID, apnAttr));
917 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(DEFAULT_SIM_SLOT_ID, apnAttr));
918 std::string ipType;
919 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(INVALID_SLOTID, ipType));
920 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(DEFAULT_SIM_SLOT_ID, ipType));
921 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(INVALID_SLOTID, true));
922 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(DEFAULT_SIM_SLOT_ID, true));
923 }
924
925 /**
926 * @tc.number Telephony_CellularDataService_006
927 * @tc.name test error branch
928 * @tc.desc Function test
929 */
930 HWTEST_F(BranchTest, Telephony_CellularDataService_006, Function | MediumTest | Level3)
931 {
932 DataAccessToken token;
933 CellularDataService service;
934 std::vector<std::u16string> strV;
935 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
936 service.state_ = ServiceRunningState::STATE_RUNNING;
937 service.OnStart();
938 service.InitModule();
939 uint32_t supplierId;
940 ASSERT_NE(TELEPHONY_ERR_FAIL,
941 service.GetCellularDataSupplierId(DEFAULT_SIM_SLOT_ID, NetCap::NET_CAPABILITY_END, supplierId));
942 ASSERT_NE(TELEPHONY_ERR_FAIL,
943 service.GetCellularDataSupplierId(DEFAULT_SIM_SLOT_ID, NetCap::NET_CAPABILITY_INTERNET, supplierId));
944 auto apnManager = std::make_shared<ApnManager>();
945 apnManager->InitApnHolders();
946 auto apnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
947 apnHolder->SetApnState(PROFILE_STATE_CONNECTED);
948 ASSERT_NE(TELEPHONY_ERR_FAIL, service.CorrectNetSupplierNoAvailable(DEFAULT_SIM_SLOT_ID));
949 apnHolder->SetApnState(PROFILE_STATE_IDLE);
950 ASSERT_NE(TELEPHONY_ERR_FAIL, service.CorrectNetSupplierNoAvailable(DEFAULT_SIM_SLOT_ID));
951 ASSERT_NE(TELEPHONY_ERR_FAIL, service.CorrectNetSupplierNoAvailable(INVALID_SLOTID));
952 int32_t regState;
953 ASSERT_NE(TELEPHONY_ERR_FAIL, service.GetSupplierRegisterState(0, regState));
954 }
955
956 /**
957 * @tc.number Telephony_CellularDataService_007
958 * @tc.name test error branch
959 * @tc.desc Function test
960 */
961 HWTEST_F(BranchTest, Telephony_CellularDataService_007, Function | MediumTest | Level3)
962 {
963 CellularDataService service;
964 std::vector<std::u16string> strV;
965 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
966 service.state_ = ServiceRunningState::STATE_RUNNING;
967 service.OnStart();
968 service.InitModule();
969 system::SetParameter("persist.edm.mobile_data_policy", "none");
970 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
971 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
972 system::SetParameter("persist.edm.mobile_data_policy", "force_open");
973 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
974 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
975 service.GetFlowDataInfoDump();
976 service.OnStop();
977 system::SetParameter("persist.edm.mobile_data_policy", "none");
978 }
979
980 /**
981 * @tc.number Telephony_CellularDataService_008
982 * @tc.name test error branch
983 * @tc.desc Function test
984 */
985 HWTEST_F(BranchTest, Telephony_CellularDataService_008, Function | MediumTest | Level3)
986 {
987 CellularDataService service;
988 std::vector<std::u16string> strV;
989 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
990 service.state_ = ServiceRunningState::STATE_RUNNING;
991 service.OnStart();
992 service.InitModule();
993 system::SetParameter("persist.edm.mobile_data_policy", "none");
994 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
995 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
996 system::SetParameter("persist.edm.mobile_data_policy", "disallow");
997 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
998 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
999 service.GetFlowDataInfoDump();
1000 service.OnStop();
1001 system::SetParameter("persist.edm.mobile_data_policy", "none");
1002 }
1003
1004 /**
1005 * @tc.number CellularDataController_001
1006 * @tc.name test error branch
1007 * @tc.desc Function test
1008 */
1009 HWTEST_F(BranchTest, Telephony_CellularDataController_001, Function | MediumTest | Level3)
1010 {
1011 CellularDataController controller { 0 };
1012 controller.RegisterEvents();
1013 controller.Init();
1014 controller.cellularDataHandler_ = nullptr;
1015 NetRequest request;
1016 ASSERT_FALSE(controller.ReleaseNet(request));
1017 ASSERT_FALSE(controller.RequestNet(request));
1018 ASSERT_NE(controller.SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
1019 if (controller.systemAbilityListener_ != nullptr) {
1020 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
1021 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
1022 controller.systemAbilityListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
1023 controller.systemAbilityListener_->OnAddSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
1024 controller.systemAbilityListener_->OnAddSystemAbility(0, "test");
1025 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
1026 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
1027 controller.systemAbilityListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
1028 controller.systemAbilityListener_->OnRemoveSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
1029 controller.systemAbilityListener_->OnRemoveSystemAbility(0, "test");
1030 }
1031 bool dataEnabled = false;
1032 controller.IsCellularDataEnabled(dataEnabled);
1033 ASSERT_FALSE(dataEnabled);
1034 controller.SetPolicyDataOn(true);
1035 ASSERT_NE(controller.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
1036 EXPECT_EQ(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState());
1037 EXPECT_EQ(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState(""));
1038 bool dataRoamingEnabled = false;
1039 controller.IsCellularDataRoamingEnabled(dataRoamingEnabled);
1040 ASSERT_FALSE(dataRoamingEnabled);
1041 ASSERT_FALSE(controller.HandleApnChanged());
1042 auto event = AppExecFwk::InnerEvent::Get(0);
1043 controller.ProcessEvent(event);
1044 event = nullptr;
1045 controller.ProcessEvent(event);
1046 controller.RegisterEvents();
1047 ASSERT_FALSE(controller.IsRestrictedMode());
1048 ASSERT_EQ(DisConnectionReason::REASON_NORMAL, controller.GetDisConnectionReason());
1049 controller.HasInternetCapability(0);
1050 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
1051 ASSERT_FALSE(controller.ClearAllConnections(reason));
1052 ASSERT_FALSE(controller.ChangeConnectionForDsds(false));
1053 controller.UnRegisterEvents();
1054 ASSERT_FALSE(controller.EstablishAllApnsIfConnectable());
1055 ASSERT_FALSE(controller.HandleApnChanged());
1056 ASSERT_FALSE(controller.GetCellularDataFlowType());
1057 }
1058
1059 /**
1060 * @tc.number CellularDataController_002
1061 * @tc.name test error branch
1062 * @tc.desc Function test
1063 */
1064 HWTEST_F(BranchTest, Telephony_CellularDataController_002, Function | MediumTest | Level3)
1065 {
1066 CellularDataController controller { 0 };
1067 controller.RegisterEvents();
1068 controller.Init();
1069 NetRequest request;
1070 controller.ReleaseNet(request);
1071 controller.RequestNet(request);
1072 controller.SetCellularDataEnable(true);
1073 controller.SetPolicyDataOn(true);
1074 ASSERT_TRUE(controller.HandleApnChanged());
1075 bool dataEnabled = false;
1076 controller.IsCellularDataEnabled(dataEnabled);
1077 ASSERT_TRUE(dataEnabled);
1078 ASSERT_NE(controller.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
1079 ASSERT_NE(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState());
1080 ASSERT_NE(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState(""));
1081 if (controller.systemAbilityListener_ != nullptr) {
1082 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
1083 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
1084 controller.systemAbilityListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
1085 controller.systemAbilityListener_->OnAddSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
1086 controller.systemAbilityListener_->OnAddSystemAbility(0, "test");
1087 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
1088 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
1089 controller.systemAbilityListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
1090 controller.systemAbilityListener_->OnRemoveSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
1091 controller.systemAbilityListener_->OnRemoveSystemAbility(0, "test");
1092 }
1093 bool dataRoamingEnabled = false;
1094 controller.IsCellularDataRoamingEnabled(dataRoamingEnabled);
1095 ASSERT_FALSE(dataRoamingEnabled);
1096 ASSERT_TRUE(controller.HandleApnChanged());
1097 auto event = AppExecFwk::InnerEvent::Get(0);
1098 controller.ProcessEvent(event);
1099 event = nullptr;
1100 controller.ProcessEvent(event);
1101 controller.RegisterEvents();
1102 ASSERT_FALSE(controller.IsRestrictedMode());
1103 ASSERT_EQ(DisConnectionReason::REASON_NORMAL, controller.GetDisConnectionReason());
1104 controller.HasInternetCapability(0);
1105 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
1106 ASSERT_TRUE(controller.ClearAllConnections(reason));
1107 ASSERT_TRUE(controller.EstablishAllApnsIfConnectable());
1108 controller.ChangeConnectionForDsds(false);
1109 ASSERT_FALSE(controller.GetCellularDataFlowType());
1110 controller.UnRegisterEvents();
1111 if (controller.cellularDataHandler_ != nullptr) {
1112 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
1113 controller.cellularDataHandler_->RemoveAllEvents();
1114 sleep(SLEEP_TIME_SECONDS);
1115 }
1116 }
1117
1118 /**
1119 * @tc.number CellularDataController_003
1120 * @tc.name test error branch
1121 * @tc.desc Function test
1122 */
1123 HWTEST_F(BranchTest, Telephony_CellularDataController_003, Function | MediumTest | Level3)
1124 {
1125 CellularDataController controller { 0 };
1126 controller.RegisterEvents();
1127 controller.Init();
1128 ApnItem::Attribute apnAttr;
1129 controller.GetDataConnApnAttr(apnAttr);
1130 std::string str = "";
1131 ASSERT_EQ(controller.GetDataConnIpType(), str);
1132 ASSERT_EQ(controller.GetDataRecoveryState(), 0);
1133 controller.IsNeedDoRecovery(true);
1134 controller.cellularDataHandler_ = nullptr;
1135 controller.GetDataConnApnAttr(apnAttr);
1136 ASSERT_EQ(controller.GetDataConnIpType(), str);
1137 ASSERT_EQ(controller.GetDataRecoveryState(), 0);
1138 controller.IsNeedDoRecovery(true);
1139 }
1140
1141 /**
1142 * @tc.number CellularDataConnectionManager_001
1143 * @tc.name test error branch
1144 * @tc.desc Function test
1145 */
1146 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_001, Function | MediumTest | Level3)
1147 {
1148 DataConnectionManager con { 0 };
1149 con.Init();
1150 con.connectionMonitor_ = nullptr;
1151 con.ccmDefaultState_ = nullptr;
1152 con.stateMachineEventHandler_ = nullptr;
1153 std::shared_ptr<CellularDataStateMachine> stateMachine = nullptr;
1154 con.AddConnectionStateMachine(stateMachine);
1155 con.RemoveConnectionStateMachine(stateMachine);
1156 con.AddActiveConnectionByCid(stateMachine);
1157 con.GetActiveConnectionByCid(1);
1158 con.GetAllConnectionMachine();
1159 con.StartStallDetectionTimer();
1160 con.StopStallDetectionTimer();
1161 con.RegisterRadioObserver();
1162 con.UnRegisterRadioObserver();
1163 con.UpdateBandWidthsUseLte();
1164 con.GetActiveConnection();
1165 con.IsBandwidthSourceModem();
1166 ASSERT_EQ(-1, con.GetDataRecoveryState());
1167 con.IsNeedDoRecovery(true);
1168 ASSERT_TRUE(con.GetActiveConnectionByCid(0) == nullptr);
1169 ASSERT_TRUE(con.isNoActiveConnection());
1170 auto event = AppExecFwk::InnerEvent::Get(0);
1171 event = nullptr;
1172 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
1173 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
1174 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED);
1175 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
1176 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_CALL_LIST_CHANGED);
1177 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
1178 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_LINK_CAPABILITY_CHANGED);
1179 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
1180 event = AppExecFwk::InnerEvent::Get(0);
1181 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
1182 ccmDefaultState.RadioDataCallListChanged(event);
1183 ccmDefaultState.UpdateNetworkInfo(event);
1184 ccmDefaultState.RadioLinkCapabilityChanged(event);
1185 con.GetDataFlowType();
1186 con.GetDefaultBandWidthsConfig();
1187 con.GetDefaultTcpBufferConfig();
1188 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
1189 con.UpdateCallState(0);
1190 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
1191 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
1192 }
1193
1194 /**
1195 * @tc.number CellularDataConnectionManager_002
1196 * @tc.name test error branch
1197 * @tc.desc Function test
1198 */
1199 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_002, Function | MediumTest | Level3)
1200 {
1201 DataConnectionManager con { 0 };
1202 con.Init();
1203 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1204 std::shared_ptr<CellularDataStateMachine> stateMachine = machine->CreateCellularDataConnect(0);
1205 con.AddConnectionStateMachine(stateMachine);
1206 con.RemoveConnectionStateMachine(stateMachine);
1207 con.AddActiveConnectionByCid(stateMachine);
1208 con.GetActiveConnectionByCid(1);
1209 con.GetAllConnectionMachine();
1210 con.StartStallDetectionTimer();
1211 con.StopStallDetectionTimer();
1212 con.RegisterRadioObserver();
1213 con.UnRegisterRadioObserver();
1214 con.uplinkUseLte_ = true;
1215 con.UpdateBandWidthsUseLte();
1216 con.GetActiveConnection();
1217 con.IsBandwidthSourceModem();
1218 ASSERT_NE(-1, con.GetDataRecoveryState());
1219 con.IsNeedDoRecovery(true);
1220 con.GetActiveConnectionByCid(0);
1221 con.isNoActiveConnection();
1222 auto event = AppExecFwk::InnerEvent::Get(0);
1223 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
1224 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
1225 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED);
1226 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
1227 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_CALL_LIST_CHANGED);
1228 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
1229 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_LINK_CAPABILITY_CHANGED);
1230 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
1231 event = AppExecFwk::InnerEvent::Get(0);
1232 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
1233 ccmDefaultState.RadioDataCallListChanged(event);
1234 ccmDefaultState.UpdateNetworkInfo(event);
1235 ccmDefaultState.RadioLinkCapabilityChanged(event);
1236 con.GetDataFlowType();
1237 con.GetDefaultBandWidthsConfig();
1238 con.GetDefaultTcpBufferConfig();
1239 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
1240 con.UpdateCallState(0);
1241 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
1242 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
1243 }
1244
1245 /**
1246 * @tc.number DataConnectionMonitor_001
1247 * @tc.name test error branch
1248 * @tc.desc Function test
1249 */
1250 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_001, Function | MediumTest | Level3)
1251 {
1252 DataConnectionManager con { 0 };
1253 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
1254 con.connectionMonitor_->trafficManager_ = nullptr;
1255 con.connectionMonitor_->stallDetectionTrafficManager_ = nullptr;
1256 con.connectionMonitor_->UpdateFlowInfo();
1257 con.connectionMonitor_->UpdateCallState(0);
1258 con.connectionMonitor_->OnStallDetectionTimer();
1259 con.connectionMonitor_->StopStallDetectionTimer();
1260 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
1261 con.connectionMonitor_->HandleRecovery();
1262 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
1263 con.connectionMonitor_->HandleRecovery();
1264 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
1265 con.connectionMonitor_->HandleRecovery();
1266 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
1267 con.connectionMonitor_->HandleRecovery();
1268 con.connectionMonitor_->EndNetStatistics();
1269 con.connectionMonitor_->UpdateNetTrafficState();
1270 auto event = AppExecFwk::InnerEvent::Get(0);
1271 con.connectionMonitor_->SetPreferredNetworkPara(event);
1272 con.connectionMonitor_->UpdateDataFlowType();
1273 con.connectionMonitor_->ProcessEvent(event);
1274 event = nullptr;
1275 con.connectionMonitor_->ProcessEvent(event);
1276 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
1277 }
1278
1279 /**
1280 * @tc.number DataConnectionMonitor_002
1281 * @tc.name test error branch
1282 * @tc.desc Function test
1283 */
1284 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_002, Function | MediumTest | Level3)
1285 {
1286 DataConnectionManager con { 0 };
1287 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
1288 con.connectionMonitor_->UpdateFlowInfo();
1289 con.connectionMonitor_->UpdateCallState(0);
1290 con.connectionMonitor_->OnStallDetectionTimer();
1291 con.connectionMonitor_->StopStallDetectionTimer();
1292 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
1293 con.connectionMonitor_->HandleRecovery();
1294 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
1295 con.connectionMonitor_->HandleRecovery();
1296 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
1297 con.connectionMonitor_->HandleRecovery();
1298 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
1299 con.connectionMonitor_->HandleRecovery();
1300 con.connectionMonitor_->EndNetStatistics();
1301 con.connectionMonitor_->UpdateNetTrafficState();
1302 auto event = AppExecFwk::InnerEvent::Get(0);
1303 con.connectionMonitor_->SetPreferredNetworkPara(event);
1304 con.connectionMonitor_->UpdateDataFlowType();
1305 con.connectionMonitor_->ProcessEvent(event);
1306 event = nullptr;
1307 con.connectionMonitor_->ProcessEvent(event);
1308 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
1309 }
1310
1311 /**
1312
1313 @tc.number DataConnectionMonitor_003
1314 @tc.name test error branch
1315 @tc.desc Function test
1316 */
1317 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_003, Function | MediumTest | Level3)
1318 {
1319 std::shared_ptr<DataConnectionMonitor> dataConnectionMonitor = std::make_shared<DataConnectionMonitor>(0);
1320 ASSERT_FALSE(dataConnectionMonitor == nullptr);
1321 dataConnectionMonitor->HandleScreenStateChanged(false);
1322 dataConnectionMonitor->HandleScreenStateChanged(true);
1323 ASSERT_FALSE(dataConnectionMonitor->IsVsimEnabled());
1324 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
1325 auto getVSimSlotId = TELEPHONY_EXT_WRAPPER.getVSimSlotId_;
1326 auto isVSimEnabled = TELEPHONY_EXT_WRAPPER.isVSimEnabled_;
1327 TELEPHONY_EXT_WRAPPER.getVSimSlotId_ = nullptr;
1328 ASSERT_FALSE(dataConnectionMonitor->IsVsimEnabled());
1329 TELEPHONY_EXT_WRAPPER.isVSimEnabled_ = nullptr;
1330 ASSERT_FALSE(dataConnectionMonitor->IsVsimEnabled());
1331 TELEPHONY_EXT_WRAPPER.getVSimSlotId_ = getVSimSlotId;
1332 ASSERT_FALSE(dataConnectionMonitor->IsVsimEnabled());
1333 TELEPHONY_EXT_WRAPPER.isVSimEnabled_ = isVSimEnabled;
1334 #endif
1335 }
1336
1337 /**
1338 * @tc.number CellularDataUtils_001
1339 * @tc.name test error branch
1340 * @tc.desc Function test
1341 */
1342 HWTEST_F(BranchTest, Telephony_CellularDataUtils_001, Function | MediumTest | Level3)
1343 {
1344 ASSERT_EQ("unknown",
1345 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_UNKNOWN)));
1346 ASSERT_EQ(
1347 "EDGE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_GSM)));
1348 ASSERT_EQ("1xRTT",
1349 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_1XRTT)));
1350 ASSERT_EQ("UMTS",
1351 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_WCDMA)));
1352 ASSERT_EQ(
1353 "HSPA", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPA)));
1354 ASSERT_EQ("HSPAP",
1355 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPAP)));
1356 ASSERT_EQ("TD-SCDMA",
1357 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_TD_SCDMA)));
1358 ASSERT_EQ(
1359 "EVDO", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EVDO)));
1360 ASSERT_EQ("eHRPD",
1361 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EHRPD)));
1362 ASSERT_EQ(
1363 "LTE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE)));
1364 ASSERT_EQ("LTE_CA",
1365 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE_CA)));
1366 ASSERT_EQ("IWAN",
1367 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_IWLAN)));
1368 ASSERT_EQ(
1369 "NR", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_NR)));
1370 ASSERT_EQ(
1371 "unknown", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(INVALID_SLOTID)));
1372 ASSERT_TRUE(CellularDataUtils::Split("", "").empty());
1373 EXPECT_GE(DelayedSingleton<CellularDataClient>::GetInstance()->GetCellularDataFlowType(), 0);
1374 auto recipient =
1375 std::make_shared<CellularDataClient::CellularDataDeathRecipient>(CellularDataClient::GetInstance());
1376 recipient->OnRemoteDied(nullptr);
1377 EXPECT_GE(DelayedSingleton<CellularDataClient>::GetInstance()->GetCellularDataFlowType(), 0);
1378 }
1379
1380 /**
1381 * @tc.number Telephony_ApnHolder_001
1382 * @tc.name test error branch
1383 * @tc.desc Function test
1384 */
1385 HWTEST_F(BranchTest, Telephony_ApnHolder_001, Function | MediumTest | Level3)
1386 {
1387 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1388 apnHolder->ReleaseAllCellularData();
1389 apnHolder->GetNextRetryApn();
1390 std::vector<sptr<ApnItem>> matchedApns;
1391 apnHolder->SetAllMatchedApns(matchedApns);
1392 apnHolder->GetRetryDelay(0, 0, RetryScene::RETRY_SCENE_OTHERS, true);
1393 apnHolder->apnItem_ = nullptr;
1394 apnHolder->SetApnBadState(true);
1395 EXPECT_EQ(apnHolder->GetCurrentApn(), nullptr);
1396 sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1397 apnHolder->SetCurrentApn(apnItem);
1398 apnHolder->SetApnBadState(true);
1399 EXPECT_TRUE(apnItem->IsBadApn());
1400 apnHolder->SetApnBadState(false);
1401 EXPECT_FALSE(apnItem->IsBadApn());
1402 apnHolder->GetCurrentApn();
1403 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1404 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
1405 apnHolder->GetApnState();
1406 apnHolder->IsDataCallEnabled();
1407 apnHolder->GetApnType();
1408 apnHolder->ReleaseDataConnection();
1409 apnHolder->cellularDataStateMachine_ = nullptr;
1410 apnHolder->ReleaseDataConnection();
1411 apnHolder->SetCellularDataStateMachine(apnHolder->cellularDataStateMachine_);
1412 apnHolder->InitialApnRetryCount();
1413 apnHolder->GetCellularDataStateMachine();
1414 apnHolder->GetCapability();
1415 apnHolder->GetPriority();
1416 apnHolder->InitialApnRetryCount();
1417 NetRequest request;
1418 request.ident = "test";
1419 request.capability = -1;
1420 apnHolder->RequestCellularData(request);
1421 apnHolder->ReleaseCellularData(request);
1422 apnHolder->RequestCellularData(request);
1423 apnHolder->ReleaseCellularData(request);
1424 ASSERT_FALSE(apnHolder->IsEmergencyType());
1425 ASSERT_FALSE(apnHolder->IsMmsType());
1426 EXPECT_GE(apnHolder->GetProfileId(DATA_CONTEXT_ROLE_DEFAULT), DATA_PROFILE_DEFAULT);
1427 EXPECT_GE(apnHolder->GetProfileId("test"), DATA_PROFILE_DEFAULT);
1428 EXPECT_GE(apnHolder->GetProfileId(DATA_CONTEXT_ROLE_BIP), DATA_PROFILE_BIP);
1429 }
1430
1431 /**
1432 * @tc.number Telephony_ApnHolder_002
1433 * @tc.name test error branch
1434 * @tc.desc Function test
1435 */
1436 HWTEST_F(BranchTest, Telephony_ApnHolder_002, Function | MediumTest | Level3)
1437 {
1438 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1439 std::vector<sptr<ApnItem>> newMatchedApns;
1440 std::vector<sptr<ApnItem>> oldMatchedApns;
1441 apnHolder->SetAllMatchedApns(oldMatchedApns);
1442 ASSERT_FALSE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1443 sptr<ApnItem> apnItemFirst = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1444 newMatchedApns.push_back(apnItemFirst);
1445 oldMatchedApns.push_back(apnItemFirst);
1446 apnHolder->SetAllMatchedApns(oldMatchedApns);
1447 ASSERT_TRUE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1448 sptr<ApnItem> apnItemSecond = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1449 newMatchedApns.push_back(apnItemSecond);
1450 ASSERT_FALSE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1451 }
1452
1453 /**
1454 * @tc.number Telephony_ApnHolder_003
1455 * @tc.name test error branch
1456 * @tc.desc Function test
1457 */
1458 HWTEST_F(BranchTest, Telephony_ApnHolder_003, Function | MediumTest | Level3)
1459 {
1460 sptr<ApnItem> newApnItem;
1461 sptr<ApnItem> oldApnItem;
1462 ASSERT_FALSE(ApnHolder::IsSameApnItem(newApnItem, oldApnItem, true));
1463 oldApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1464 ASSERT_FALSE(ApnHolder::IsSameApnItem(newApnItem, oldApnItem, true));
1465 newApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1466 oldApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1467 ASSERT_TRUE(ApnHolder::IsSameApnItem(newApnItem, oldApnItem, false));
1468 oldApnItem->CanDealWithType(DATA_CONTEXT_ROLE_DEFAULT);
1469 oldApnItem->GetApnTypes();
1470 PdpProfile apnBean;
1471 oldApnItem->MakeApn(apnBean);
1472 oldApnItem->MarkBadApn(false);
1473 ASSERT_FALSE(oldApnItem->IsBadApn());
1474 }
1475
1476 /**
1477 * @tc.number NetworkSearchCallback_Test_01
1478 * @tc.name TestDump
1479 * @tc.desc Function test
1480 */
1481 HWTEST_F(BranchTest, NetworkSearchCallback_Test_01, Function | MediumTest | Level3)
1482 {
1483 auto networkSearchCallback = std::make_shared<NetworkSearchCallback>();
1484 networkSearchCallback->ClearCellularDataConnections(0);
1485 networkSearchCallback->ClearCellularDataConnections(-1);
1486 ASSERT_FALSE(networkSearchCallback->HasInternetCapability(0, 0));
1487 StateNotification::GetInstance().UpdateCellularDataConnectState(0, PROFILE_STATE_DISCONNECTING, 0);
1488 StateNotification::GetInstance().OnUpDataFlowtype(0, CellDataFlowType::DATA_FLOW_TYPE_NONE);
1489 StateNotification::GetInstance().OnUpDataFlowtype(1, CellDataFlowType::DATA_FLOW_TYPE_UP_DOWN);
1490 StateNotification::GetInstance().OnUpDataFlowtype(2, CellDataFlowType::DATA_FLOW_TYPE_UP_DOWN);
1491 ASSERT_FALSE(networkSearchCallback->HasInternetCapability(-1, -1));
1492 }
1493
1494 /**
1495 * @tc.number Active_Test_01
1496 * @tc.name TestDump
1497 * @tc.desc Function test
1498 */
1499 HWTEST_F(BranchTest, Active_Test_01, Function | MediumTest | Level3)
1500 {
1501 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1502 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1503 cellularMachine->Init();
1504 auto active = static_cast<Active *>(cellularMachine->activeState_.GetRefPtr());
1505 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1506 active->stateMachine_ = stateMachine1;
1507 active->StateBegin();
1508 active->StateEnd();
1509 auto event = AppExecFwk::InnerEvent::Get(0);
1510 event = nullptr;
1511 active->RefreshTcpBufferSizes();
1512 active->RefreshConnectionBandwidths();
1513 active->ProcessConnectDone(event);
1514 ASSERT_FALSE(active->StateProcess(event));
1515 ASSERT_FALSE(active->ProcessDisconnectDone(event));
1516 ASSERT_FALSE(active->ProcessDisconnectAllDone(event));
1517 ASSERT_FALSE(active->ProcessLostConnection(event));
1518 ASSERT_FALSE(active->ProcessRilAdapterHostDied(event));
1519 ASSERT_FALSE(active->ProcessLinkCapabilityChanged(event));
1520 ASSERT_FALSE(active->ProcessNrStateChanged(event));
1521 ASSERT_FALSE(active->ProcessNrFrequencyChanged(event));
1522 ASSERT_FALSE(active->ProcessDataConnectionComplete(event));
1523 ASSERT_FALSE(active->ProcessDataConnectionVoiceCallStartedOrEnded(event));
1524 ASSERT_FALSE(active->ProcessDataConnectionRoamOn(event));
1525 ASSERT_FALSE(active->ProcessDataConnectionRoamOff(event));
1526 }
1527
1528 /**
1529 * @tc.number Activating_Test_01
1530 * @tc.name TestDump
1531 * @tc.desc Function test
1532 */
1533 HWTEST_F(BranchTest, Activating_Test_02, Function | MediumTest | Level3)
1534 {
1535 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1536 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1537 cellularMachine->Init();
1538 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
1539 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1540 activating->stateMachine_ = stateMachine1;
1541 activating->StateBegin();
1542 activating->StateEnd();
1543 auto event = AppExecFwk::InnerEvent::Get(0);
1544 event = nullptr;
1545 activating->ProcessConnectTimeout(event);
1546 ASSERT_FALSE(activating->RilActivatePdpContextDone(event));
1547 ASSERT_FALSE(activating->RilErrorResponse(event));
1548 ASSERT_FALSE(activating->StateProcess(event));
1549 auto rsp = std::make_shared<RadioResponseInfo>();
1550 auto event2 = AppExecFwk::InnerEvent::Get<RadioResponseInfo>(0, rsp);
1551 EXPECT_FALSE(activating->RilErrorResponse(event2));
1552 activating->rilErrTryCount_ = 5;
1553 EXPECT_FALSE(activating->RilErrorResponse(event2));
1554 activating->rilErrTryCount_ = 0;
1555 EXPECT_FALSE(activating->RilErrorResponse(event2));
1556 }
1557
1558 /**
1559 * @tc.number Inactive_Test_01
1560 * @tc.name TestDump
1561 * @tc.desc Function test
1562 */
1563 HWTEST_F(BranchTest, Inactive_Test_01, Function | MediumTest | Level3)
1564 {
1565 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1566 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1567 cellularMachine->Init();
1568 auto inactive = static_cast<Inactive *>(cellularMachine->inActiveState_.GetRefPtr());
1569 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1570 inactive->SetStateMachine(stateMachine1);
1571 auto event = AppExecFwk::InnerEvent::Get(0);
1572 event = nullptr;
1573 inactive->StateBegin();
1574 inactive->StateEnd();
1575 inactive->SetDeActiveApnTypeId(0);
1576 ASSERT_FALSE(inactive->StateProcess(event));
1577 }
1578
1579 /**
1580 * @tc.number Disconnecting_Test_01
1581 * @tc.name TestDump
1582 * @tc.desc Function test
1583 */
1584 HWTEST_F(BranchTest, Disconnecting_Test_01, Function | MediumTest | Level3)
1585 {
1586 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1587 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1588 cellularMachine->Init();
1589 auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
1590 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1591 disconnecting->stateMachine_ = stateMachine1;
1592 auto event = AppExecFwk::InnerEvent::Get(0);
1593 event = nullptr;
1594 disconnecting->StateBegin();
1595 disconnecting->StateEnd();
1596 disconnecting->ProcessDisconnectTimeout(event);
1597 disconnecting->ProcessRilAdapterHostDied(event);
1598 ASSERT_FALSE(disconnecting->StateProcess(event));
1599 }
1600
1601 /**
1602 * @tc.number Default_Test_01
1603 * @tc.name TestDump
1604 * @tc.desc Function test
1605 */
1606 HWTEST_F(BranchTest, Default_Test_01, Function | MediumTest | Level3)
1607 {
1608 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1609 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1610 cellularMachine->Init();
1611 auto mDefault = static_cast<Default *>(cellularMachine->defaultState_.GetRefPtr());
1612 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1613 mDefault->stateMachine_ = stateMachine1;
1614 auto event = AppExecFwk::InnerEvent::Get(0);
1615 event = nullptr;
1616 mDefault->StateBegin();
1617 mDefault->StateEnd();
1618 ASSERT_FALSE(mDefault->StateProcess(event));
1619 ASSERT_FALSE(mDefault->ProcessConnectDone(event));
1620 ASSERT_FALSE(mDefault->ProcessDisconnectDone(event));
1621 ASSERT_FALSE(mDefault->ProcessDisconnectAllDone(event));
1622 ASSERT_FALSE(mDefault->ProcessDataConnectionDrsOrRatChanged(event));
1623 ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOn(event));
1624 ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOff(event));
1625 }
1626
1627 /**
1628 * @tc.number ApnManager_Test_01
1629 * @tc.name TestDump
1630 * @tc.desc Function test
1631 */
1632 HWTEST_F(BranchTest, ApnManager_Test_01, Function | MediumTest | Level3)
1633 {
1634 auto apnManager = std::make_shared<ApnManager>();
1635 EXPECT_GE(apnManager->CreateAllApnItemByDatabase(0), 0);
1636 EXPECT_EQ(apnManager->CreateAllApnItemByDatabase(0), 0);
1637 apnManager->ResetApns(0);
1638 std::string operatorNumeric = "46011";
1639 apnManager->GetCTOperator(0, operatorNumeric);
1640 EXPECT_EQ(operatorNumeric, "46011");
1641 apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
1642 apnManager->apnHolders_.push_back(nullptr);
1643 apnManager->ClearAllApnBad();
1644 EXPECT_EQ(apnManager->apnHolders_.back(), nullptr);
1645 apnManager->apnHolders_.pop_back();
1646 apnManager->FindApnNameByApnId(1);
1647 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1648 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1649 cellularMachine->Init();
1650 ASSERT_TRUE(apnManager->IsDataConnectionNotUsed(cellularMachine));
1651 auto helper = CellularDataRdbHelper::GetInstance();
1652 helper->ResetApns(0);
1653 std::shared_ptr<DataShare::DataShareResultSet> result = nullptr;
1654 std::vector<PdpProfile> apnVec;
1655 helper->ReadMvnoApnResult(result, "", apnVec);
1656 PdpProfile apnBean;
1657 ASSERT_FALSE(helper->IsMvnoDataMatched("", apnBean));
1658 apnBean.mvnoType = MvnoType::ICCID;
1659 apnBean.mvnoMatchData = "test";
1660 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1661 apnBean.mvnoType = MvnoType::SPN;
1662 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1663 apnBean.mvnoType = MvnoType::GID1;
1664 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1665 apnBean.mvnoType = MvnoType::IMSI;
1666 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1667 apnBean.mvnoType = "error";
1668 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1669 helper->QueryPreferApn(0, apnVec);
1670 ASSERT_FALSE(helper->QueryPreferApn(-1, apnVec));
1671 }
1672
1673 /**
1674 * @tc.number IsMvnoDataMatched_Test_01
1675 * @tc.name Test IsMvnoDataMatched
1676 * @tc.desc Function test
1677 */
1678 HWTEST_F(BranchTest, IsMvnoDataMatched_Test_01, Function | MediumTest | Level3)
1679 {
1680 auto helper = CellularDataRdbHelper::GetInstance();
1681 PdpProfile apnBean;
1682 ASSERT_EQ(apnBean.mvnoMatchData, "");
1683 ASSERT_EQ(apnBean.mvnoType, "");
1684 ASSERT_FALSE(helper->IsMvnoDataMatched("", apnBean));
1685
1686 apnBean.mvnoType = MvnoType::ICCID;
1687 apnBean.mvnoMatchData = "";
1688 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1689
1690 apnBean.mvnoType = MvnoType::SPN;
1691 apnBean.mvnoMatchData = "\\";
1692 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1693
1694 apnBean.mvnoType = MvnoType::IMSI;
1695 apnBean.mvnoMatchData = "";
1696 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1697
1698 apnBean.mvnoType = MvnoType::GID1;
1699 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1700 }
1701
1702 /**
1703 * @tc.number IdleState_Test_01
1704 * @tc.name test error branch
1705 * @tc.desc Function test
1706 */
1707 HWTEST_F(BranchTest, Idle_Test_01, Function | MediumTest | Level3)
1708 {
1709 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1710 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1711 incallStateMachineTest->CreateIncallDataStateMachine(0);
1712 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1713 incallStateMachine->GetCurrentState();
1714 incallStateMachine->GetSlotId();
1715 incallStateMachine->GetCallState();
1716 incallStateMachine->HasAnyConnectedState();
1717 incallStateMachine->UpdateCallState(TelCallStatus::CALL_STATUS_ALERTING);
1718 incallStateMachine->IsIncallDataSwitchOn();
1719 incallStateMachine->IsSecondaryCanActiveData();
1720 incallStateMachine->CanActiveDataByRadioTech();
1721 auto idleState = static_cast<IdleState *>(incallStateMachine->idleState_.GetRefPtr());
1722 auto event = AppExecFwk::InnerEvent::Get(0);
1723 event = nullptr;
1724 idleState->StateBegin();
1725 ASSERT_FALSE(idleState->StateProcess(event));
1726 ASSERT_TRUE(idleState->ProcessCallStarted(event));
1727 ASSERT_TRUE(idleState->ProcessCallEnded(event));
1728 ASSERT_TRUE(idleState->ProcessSettingsOn(event));
1729 ASSERT_TRUE(idleState->ProcessDsdsChanged(event));
1730 idleState->StateEnd();
1731 }
1732
1733 /**
1734 * @tc.number IdleState_Test_02
1735 * @tc.name test error branch
1736 * @tc.desc Function test
1737 */
1738 HWTEST_F(BranchTest, Idle_Test_02, Function | MediumTest | Level3)
1739 {
1740 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1741 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1742 incallStateMachineTest->CreateIncallDataStateMachine(0);
1743 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1744 auto idleState = static_cast<IdleState *>(incallStateMachine->idleState_.GetRefPtr());
1745 auto event = AppExecFwk::InnerEvent::Get(0);
1746 event = nullptr;
1747 idleState->StateBegin();
1748 std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
1749 if (settingHelper == nullptr) {
1750 return;
1751 }
1752 Uri intelligenceNetworkUri(CELLULAR_DATA_SETTING_INTELLIGENCE_NETWORK_URI);
1753 settingHelper->PutValue(intelligenceNetworkUri, INTELLIGENCE_NETWORK_COLUMN_ENABLE, 0);
1754 incallStateMachine->IsIncallDataSwitchOn();
1755 settingHelper->PutValue(intelligenceNetworkUri, INTELLIGENCE_NETWORK_COLUMN_ENABLE, 1);
1756 Uri smartDualCardUri(CELLULAR_DATA_SETTING_INTELLIGENCE_SWITCH_URI);
1757 settingHelper->PutValue(smartDualCardUri, INTELLIGENCE_SWITCH_COLUMN_ENABLE, 0);
1758 incallStateMachine->IsIncallDataSwitchOn();
1759 settingHelper->PutValue(smartDualCardUri, INTELLIGENCE_SWITCH_COLUMN_ENABLE, 1);
1760 ASSERT_NE(incallStateMachine->IsIncallDataSwitchOn(), -1);
1761 idleState->StateEnd();
1762 }
1763
1764 /**
1765 * @tc.number ActivatingSecondaryState_Test_01
1766 * @tc.name test error branch
1767 * @tc.desc Function test
1768 */
1769 HWTEST_F(BranchTest, ActivatingSecondaryState_Test_01, Function | MediumTest | Level3)
1770 {
1771 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1772 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1773 incallStateMachineTest->CreateIncallDataStateMachine(0);
1774 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1775 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1776 auto activatingSecondaryState =
1777 static_cast<ActivatingSecondaryState *>(incallStateMachine->activatingSecondaryState_.GetRefPtr());
1778 auto secondaryActiveState =
1779 static_cast<SecondaryActiveState *>(incallStateMachine->secondaryActiveState_.GetRefPtr());
1780 auto event = AppExecFwk::InnerEvent::Get(0);
1781 event = nullptr;
1782 secondaryActiveState->StateBegin();
1783 activatingSecondaryState->StateBegin();
1784 ASSERT_FALSE(activatingSecondaryState->StateProcess(event));
1785 ASSERT_FALSE(secondaryActiveState->StateProcess(event));
1786 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOn(event));
1787 ASSERT_TRUE(secondaryActiveState->ProcessCallEnded(event));
1788 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOff(event));
1789 ASSERT_TRUE(secondaryActiveState->ProcessDsdsChanged(event));
1790 activatingSecondaryState->StateEnd();
1791 secondaryActiveState->StateEnd();
1792 }
1793
1794 /**
1795 * @tc.number ActivatedSecondaryState_Test_01
1796 * @tc.name test error branch
1797 * @tc.desc Function test
1798 */
1799 HWTEST_F(BranchTest, ActivatedSecondaryState_Test_01, Function | MediumTest | Level3)
1800 {
1801 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1802 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1803 incallStateMachineTest->CreateIncallDataStateMachine(0);
1804 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1805 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1806 incallStateMachine->TransitionTo(incallStateMachine->activatedSecondaryState_);
1807 auto activatedSecondaryState =
1808 static_cast<ActivatedSecondaryState *>(incallStateMachine->activatedSecondaryState_.GetRefPtr());
1809 auto secondaryActiveState =
1810 static_cast<SecondaryActiveState *>(incallStateMachine->secondaryActiveState_.GetRefPtr());
1811 auto event = AppExecFwk::InnerEvent::Get(0);
1812 event = nullptr;
1813 secondaryActiveState->StateBegin();
1814 activatedSecondaryState->StateBegin();
1815 ASSERT_FALSE(activatedSecondaryState->StateProcess(event));
1816 ASSERT_FALSE(secondaryActiveState->StateProcess(event));
1817 ASSERT_TRUE(secondaryActiveState->ProcessCallEnded(event));
1818 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOff(event));
1819 activatedSecondaryState->StateEnd();
1820 secondaryActiveState->StateEnd();
1821 }
1822
1823 /**
1824 * @tc.number DeactivatingSecondaryState_Test_01
1825 * @tc.name test error branch
1826 * @tc.desc Function test
1827 */
1828 HWTEST_F(BranchTest, DeactivatingSecondaryState_Test_01, Function | MediumTest | Level3)
1829 {
1830 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1831 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1832 incallStateMachineTest->CreateIncallDataStateMachine(0);
1833 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1834 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1835 incallStateMachine->TransitionTo(incallStateMachine->activatedSecondaryState_);
1836 incallStateMachine->TransitionTo(incallStateMachine->deactivatingSecondaryState_);
1837 auto deactivatingSecondaryState =
1838 static_cast<DeactivatingSecondaryState *>(incallStateMachine->deactivatingSecondaryState_.GetRefPtr());
1839 auto event = AppExecFwk::InnerEvent::Get(0);
1840 event = nullptr;
1841 deactivatingSecondaryState->StateBegin();
1842 ASSERT_FALSE(deactivatingSecondaryState->StateProcess(event));
1843 deactivatingSecondaryState->StateEnd();
1844 }
1845
1846 /**
1847 * @tc.number GetIpType_Test_01
1848 * @tc.name TestDump
1849 * @tc.desc Function test
1850 */
1851 HWTEST_F(BranchTest, GetIpType_Test_01, Function | MediumTest | Level3)
1852 {
1853 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1854 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1855 cellularMachine->Init();
1856 std::string result = "";
1857 std::string address = "";
1858 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1859 result = cellularMachine->GetIpType(ipInfoArray);
1860 ASSERT_TRUE(result == "");
1861 }
1862
1863 /**
1864 * @tc.number DataSwitchSettings_Test_01
1865 * @tc.name test error branch
1866 * @tc.desc Function test
1867 */
1868 HWTEST_F(BranchTest, DataSwitchSettings_Test_01, Function | MediumTest | Level3)
1869 {
1870 std::unique_ptr<DataSwitchSettings> dataSwitchSettings = std::make_unique<DataSwitchSettings>(0);
1871 dataSwitchSettings->LoadSwitchValue();
1872 bool status = true;
1873 dataSwitchSettings->QueryUserDataStatus(status);
1874 dataSwitchSettings->QueryUserDataRoamingStatus(status);
1875 dataSwitchSettings->QueryIntelligenceSwitchStatus(status);
1876 dataSwitchSettings->SetPolicyDataOn(true);
1877 ASSERT_TRUE(dataSwitchSettings->IsPolicyDataOn());
1878 dataSwitchSettings->IsAllowActiveData();
1879 dataSwitchSettings->SetUserDataOn(true);
1880 dataSwitchSettings->IsUserDataOn();
1881 dataSwitchSettings->SetCarrierDataOn(true);
1882 ASSERT_TRUE(dataSwitchSettings->IsCarrierDataOn());
1883 dataSwitchSettings->SetUserDataRoamingOn(true);
1884 dataSwitchSettings->IsUserDataRoamingOn();
1885 dataSwitchSettings->SetInternalDataOn(true);
1886 ASSERT_TRUE(dataSwitchSettings->IsInternalDataOn());
1887 dataSwitchSettings->SetIntelliSwitchOn(true);
1888 dataSwitchSettings->UpdateUserDataRoamingOn(false);
1889 ASSERT_FALSE(dataSwitchSettings->IsUserDataRoamingOn());
1890 }
1891
1892 /**
1893 * @tc.number CellularDataStateMachine_Test_01
1894 * @tc.name test error branch
1895 * @tc.desc Function test
1896 */
1897 HWTEST_F(BranchTest, CellularDataStateMachine_Test_01, Function | MediumTest | Level3)
1898 {
1899 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1900 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1901 cellularMachine->IsInactiveState();
1902 uint64_t capability = 1;
1903 cellularMachine->SetCapability(capability);
1904 cellularMachine->GetCapability();
1905 const int32_t cid = 1;
1906 cellularMachine->SetCid(cid);
1907 cellularMachine->GetSlotId();
1908 cellularMachine->GetApnItem();
1909 cellularMachine->GetCurrentState();
1910 const uint32_t upBandwidth = 0;
1911 const uint32_t downBandwidth = 0;
1912 cellularMachine->SetConnectionBandwidth(upBandwidth, downBandwidth);
1913 const std::string tcpBuffer = "";
1914 cellularMachine->SetConnectionTcpBuffer(tcpBuffer);
1915 std::string proxyIpAddress = "1234:567";
1916 std::string host = "";
1917 uint16_t port = 0;
1918 cellularMachine->SplitProxyIpAddress(proxyIpAddress, host, port);
1919 EXPECT_EQ(host, "1234");
1920 EXPECT_EQ(port, 567);
1921 EXPECT_TRUE(cellularMachine != nullptr);
1922 CellularDataDumpHelper dumpHelper;
1923 std::string result = "";
1924 dumpHelper.ShowHelp(result);
1925 EXPECT_GE(result.size(), 0);
1926 }
1927
1928 /**
1929 * @tc.number CellularDataUtils_Test_01
1930 * @tc.name test error branch
1931 * @tc.desc Function test
1932 */
1933 HWTEST_F(BranchTest, CellularDataUtils_Test_01, Function | MediumTest | Level3)
1934 {
1935 CellularDataUtils::ParseNormalIpAddr(ADDRESS);
1936 CellularDataUtils::ParseRoute(ADDRESS);
1937 CellularDataUtils::GetPrefixLen(ADDRESS, FLAG);
1938 auto cellularDataHiSysEvent = DelayedSingleton<CellularDataHiSysEvent>::GetInstance();
1939 cellularDataHiSysEvent->WriteRoamingConnectStateBehaviorEvent(1);
1940 cellularDataHiSysEvent->SetCellularDataActivateStartTime();
1941 cellularDataHiSysEvent->JudgingDataActivateTimeOut(0, 1);
1942 std::shared_ptr<DataConnectionMonitor> dataConnectionMonitor = std::make_shared<DataConnectionMonitor>(0);
1943 dataConnectionMonitor->HandleRecovery();
1944 dataConnectionMonitor->GetPdpContextList();
1945 dataConnectionMonitor->SetRadioState(0, RadioEvent::RADIO_ON);
1946 dataConnectionMonitor->GetPreferredNetworkPara();
1947 dataConnectionMonitor->GetDataFlowType();
1948 dataConnectionMonitor->IsNeedDoRecovery(true);
1949 dataConnectionMonitor->IsNeedDoRecovery(false);
1950 }
1951
1952 /**
1953 * @tc.number CellularDataUtils_Test_02
1954 * @tc.name test error branch
1955 * @tc.desc Function test
1956 */
1957 HWTEST_F(BranchTest, CellularDataUtils_Test_02, Function | MediumTest | Level3)
1958 {
1959 auto cellularDataService = DelayedSingleton<CellularDataService>::GetInstance();
1960 MessageParcel data;
1961 MessageParcel reply;
1962 MessageOption option(MessageOption::TF_SYNC);
1963 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1964 ICellularDataManagerIpcCode::COMMAND_IS_CELLULAR_DATA_ENABLED), data, reply, option), 0);
1965 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1966 ICellularDataManagerIpcCode::COMMAND_ENABLE_CELLULAR_DATA), data, reply, option), 0);
1967 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1968 ICellularDataManagerIpcCode::COMMAND_ENABLE_INTELLIGENCE_SWITCH), data, reply, option), 0);
1969 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1970 ICellularDataManagerIpcCode::COMMAND_GET_CELLULAR_DATA_STATE), data, reply, option), 0);
1971 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1972 ICellularDataManagerIpcCode::COMMAND_IS_CELLULAR_DATA_ROAMING_ENABLED), data, reply, option), 0);
1973 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1974 ICellularDataManagerIpcCode::COMMAND_ENABLE_CELLULAR_DATA_ROAMING), data, reply, option), 0);
1975 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1976 ICellularDataManagerIpcCode::COMMAND_HANDLE_APN_CHANGED), data, reply, option), 0);
1977 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1978 ICellularDataManagerIpcCode::COMMAND_GET_DEFAULT_CELLULAR_DATA_SLOT_ID), data, reply, option), 0);
1979 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1980 ICellularDataManagerIpcCode::COMMAND_GET_DEFAULT_CELLULAR_DATA_SIM_ID), data, reply, option), 0);
1981 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1982 ICellularDataManagerIpcCode::COMMAND_SET_DEFAULT_CELLULAR_DATA_SLOT_ID), data, reply, option), 0);
1983 }
1984
1985 /**
1986 * @tc.number CellularDataUtils_Test_03
1987 * @tc.name test error branch
1988 * @tc.desc Function test
1989 */
1990 HWTEST_F(BranchTest, CellularDataUtils_Test_03, Function | MediumTest | Level3)
1991 {
1992 auto cellularDataService = DelayedSingleton<CellularDataService>::GetInstance();
1993 MessageParcel data;
1994 MessageParcel reply;
1995 MessageOption option(MessageOption::TF_SYNC);
1996 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1997 ICellularDataManagerIpcCode::COMMAND_GET_CELLULAR_DATA_FLOW_TYPE), data, reply, option), 0);
1998 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
1999 ICellularDataManagerIpcCode::COMMAND_HAS_INTERNET_CAPABILITY), data, reply, option), 0);
2000 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2001 ICellularDataManagerIpcCode::COMMAND_CLEAR_CELLULAR_DATA_CONNECTIONS), data, reply, option), 0);
2002 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2003 ICellularDataManagerIpcCode::COMMAND_CLEAR_ALL_CONNECTIONS), data, reply, option), 0);
2004 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2005 ICellularDataManagerIpcCode::COMMAND_GET_DATA_CONN_APN_ATTR), data, reply, option), 0);
2006 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2007 ICellularDataManagerIpcCode::COMMAND_GET_DATA_CONN_IP_TYPE), data, reply, option), 0);
2008 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2009 ICellularDataManagerIpcCode::COMMAND_GET_APN_STATE), data, reply, option), 0);
2010 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2011 ICellularDataManagerIpcCode::COMMAND_GET_DATA_RECOVERY_STATE), data, reply, option), 0);
2012 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2013 ICellularDataManagerIpcCode::COMMAND_IS_NEED_DO_RECOVERY), data, reply, option), 0);
2014 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2015 ICellularDataManagerIpcCode::COMMAND_INIT_CELLULAR_DATA_CONTROLLER), data, reply, option), 0);
2016 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2017 ICellularDataManagerIpcCode::COMMAND_ESTABLISH_ALL_APNS_IF_CONNECTABLE), data, reply, option), 0);
2018 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2019 ICellularDataManagerIpcCode::COMMAND_RELEASE_CELLULAR_DATA_CONNECTION), data, reply, option), 0);
2020 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2021 ICellularDataManagerIpcCode::COMMAND_GET_CELLULAR_DATA_SUPPLIER_ID), data, reply, option), 0);
2022 EXPECT_GE(cellularDataService->OnRemoteRequest(static_cast<uint32_t>(
2023 ICellularDataManagerIpcCode::COMMAND_CORRECT_NET_SUPPLIER_NO_AVAILABLE), data, reply, option), 0);
2024 }
2025 /**
2026 * @tc.number CellularDataSettingsRdbHelper_Test_01
2027 * @tc.name test error branch
2028 * @tc.desc Function test
2029 */
2030 HWTEST_F(BranchTest, CellularDataSettingsRdbHelper_Test_01, Function | MediumTest | Level3)
2031 {
2032 auto settingHelper = CellularDataSettingsRdbHelper::GetInstance();
2033 if (settingHelper == nullptr) {
2034 TELEPHONY_LOGE("settingHelper is null");
2035 return;
2036 }
2037 Uri dataEnableUri(CELLULAR_DATA_SETTING_DATA_ROAMING_URI);
2038 settingHelper->RegisterSettingsObserver(dataEnableUri, nullptr);
2039 settingHelper->UnRegisterSettingsObserver(dataEnableUri, nullptr);
2040 EXPECT_TRUE(settingHelper != nullptr);
2041 }
2042
2043 /**
2044 * @tc.number FindBestCapability_Test_01
2045 * @tc.name test branch
2046 * @tc.desc Function test
2047 */
2048 HWTEST_F(BranchTest, FindBestCapability_Test_01, Function | MediumTest | Level3)
2049 {
2050 auto apnManager = std::make_shared<ApnManager>();
2051
2052 uint64_t capabilities = 1L << NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET;
2053 auto ret = apnManager->FindBestCapability(capabilities);
2054 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
2055
2056 capabilities |= 1L << NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT;
2057 ret = apnManager->FindBestCapability(capabilities);
2058 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT);
2059
2060 capabilities |= 1L << NetManagerStandard::NetCap::NET_CAPABILITY_MMS;
2061 ret = apnManager->FindBestCapability(capabilities);
2062 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_MMS);
2063 }
2064
2065 /**
2066 * @tc.number GetOverallDefaultApnState_Test_01
2067 * @tc.name test branch
2068 * @tc.desc Function test
2069 */
2070 HWTEST_F(BranchTest, GetOverallDefaultApnState_Test_01, Function | MediumTest | Level3)
2071 {
2072 auto apnManager = std::make_shared<ApnManager>();
2073 apnManager->InitApnHolders();
2074 auto &apnHolders = apnManager->apnHolders_;
2075 for (auto &apnHolder : apnHolders) {
2076 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
2077 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
2078 }
2079 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
2080 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
2081 }
2082 }
2083 auto ret = apnManager->GetOverallDefaultApnState();
2084 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_IDLE);
2085
2086 for (auto &apnHolder : apnHolders) {
2087 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
2088 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
2089 }
2090 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
2091 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
2092 }
2093 }
2094 ret = apnManager->GetOverallDefaultApnState();
2095 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
2096
2097 for (auto &apnHolder : apnHolders) {
2098 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
2099 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
2100 }
2101 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
2102 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
2103 }
2104 }
2105 ret = apnManager->GetOverallDefaultApnState();
2106 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
2107 }
2108
2109 /**
2110 * @tc.number GetOverallDefaultApnState_Test_02
2111 * @tc.name test branch
2112 * @tc.desc Function test
2113 */
2114 HWTEST_F(BranchTest, GetOverallDefaultApnState_Test_02, Function | MediumTest | Level3)
2115 {
2116 auto apnManager = std::make_shared<ApnManager>();
2117 apnManager->InitApnHolders();
2118 auto &apnHolders = apnManager->apnHolders_;
2119
2120 for (auto &apnHolder : apnHolders) {
2121 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
2122 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTED);
2123 }
2124 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
2125 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_DISCONNECTING);
2126 }
2127 }
2128 auto ret = apnManager->GetOverallDefaultApnState();
2129 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTED);
2130
2131 for (auto &apnHolder : apnHolders) {
2132 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
2133 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTED);
2134 }
2135 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
2136 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
2137 }
2138 }
2139 ret = apnManager->GetOverallDefaultApnState();
2140 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTED);
2141
2142 for (auto &apnHolder : apnHolders) {
2143 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
2144 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
2145 }
2146 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
2147 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
2148 }
2149 }
2150 ret = apnManager->GetOverallDefaultApnState();
2151 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
2152 }
2153
2154 /**
2155 * @tc.number ParseIpAddr_001
2156 * @tc.name test branch
2157 * @tc.desc Function test
2158 */
2159 HWTEST_F(BranchTest, ParseIpAddr_001, Function | MediumTest | Level0)
2160 {
2161 std::string address = "";
2162 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
2163 EXPECT_EQ(ipInfoArray.size(), 0);
2164 }
2165
2166 /**
2167 * @tc.number ParseIpAddr_002
2168 * @tc.name test branch
2169 * @tc.desc Function test
2170 */
2171 HWTEST_F(BranchTest, ParseIpAddr_002, Function | MediumTest | Level0)
2172 {
2173 std::string address = "192.000.1.1/24";
2174 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
2175 EXPECT_EQ(ipInfoArray.size(), 1);
2176 }
2177
2178 /**
2179 * @tc.number ParseIpAddr_003
2180 * @tc.name test branch
2181 * @tc.desc Function test
2182 */
2183 HWTEST_F(BranchTest, ParseIpAddr_003, Function | MediumTest | Level0)
2184 {
2185 std::string address = "192.000.1.1/24 192.000.1.2/24";
2186 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
2187 EXPECT_EQ(ipInfoArray.size(), 2);
2188 }
2189
2190 /**
2191 * @tc.number ParseIpAddr_004
2192 * @tc.name test branch
2193 * @tc.desc Function test
2194 */
2195 HWTEST_F(BranchTest, ParseIpAddr_004, Function | MediumTest | Level0)
2196 {
2197 std::string address = "2001:0000:0000:0000:0000:0000:0000:0000/64";
2198 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
2199 EXPECT_EQ(ipInfoArray.size(), 1);
2200 }
2201
2202 /**
2203 * @tc.number ParseIpAddr_005
2204 * @tc.name test branch
2205 * @tc.desc Function test
2206 */
2207 HWTEST_F(BranchTest, ParseIpAddr_005, Function | MediumTest | Level0)
2208 {
2209 std::string address = "2001:0000:0000:0000:0000:0000:0000:0000/64 2001:0000:0000:0000:0000:0000:0000:0000/64";
2210 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
2211 EXPECT_EQ(ipInfoArray.size(), 2);
2212 }
2213
2214 /**
2215 * @tc.number GetPrefixLen_001
2216 * @tc.name test branch
2217 * @tc.desc Function test
2218 */
2219 HWTEST_F(BranchTest, GetPrefixLen_001, Function | MediumTest | Level0)
2220 {
2221 std::vector<std::string> netmask;
2222 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
2223 EXPECT_EQ(result, 0);
2224 }
2225
2226 /**
2227 * @tc.number GetPrefixLen_002
2228 * @tc.name test branch
2229 * @tc.desc Function test
2230 */
2231 HWTEST_F(BranchTest, GetPrefixLen_002, Function | MediumTest | Level0)
2232 {
2233 std::vector<std::string> netmask = {"255", "invalid", "255"};
2234 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
2235 EXPECT_EQ(result, 8);
2236 }
2237
2238 /**
2239 * @tc.number GetPrefixLen_003
2240 * @tc.name test branch
2241 * @tc.desc Function test
2242 */
2243 HWTEST_F(BranchTest, GetPrefixLen_003, Function | MediumTest | Level0)
2244 {
2245 std::vector<std::string> netmask = {"255", "0", "255"};
2246 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
2247 EXPECT_EQ(result, 8);
2248 }
2249
2250 /**
2251 * @tc.number GetPrefixLen_004
2252 * @tc.name test branch
2253 * @tc.desc Function test
2254 */
2255 HWTEST_F(BranchTest, GetPrefixLen_004, Function | MediumTest | Level0)
2256 {
2257 std::vector<std::string> netmask = {"255", "254", "255"};
2258 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
2259 EXPECT_EQ(result, 15);
2260 }
2261
2262 /**
2263 * @tc.number GetPrefixLen_005
2264 * @tc.name test branch
2265 * @tc.desc Function test
2266 */
2267 HWTEST_F(BranchTest, GetPrefixLen_005, Function | MediumTest | Level0)
2268 {
2269 std::vector<std::string> netmask = {"255", "256", "255"};
2270 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
2271 EXPECT_EQ(result, 8);
2272 }
2273
2274 /**
2275 * @tc.number GetPrefixLen_006
2276 * @tc.name test branch
2277 * @tc.desc Function test
2278 */
2279 HWTEST_F(BranchTest, GetPrefixLen_006, Function | MediumTest | Level0)
2280 {
2281 std::vector<std::string> netmask = {"255", "254", "255"};
2282 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
2283 EXPECT_EQ(result, 15);
2284 }
2285
2286 /**
2287 * @tc.number GetPrefixLen_007
2288 * @tc.name test branch
2289 * @tc.desc Function test
2290 */
2291 HWTEST_F(BranchTest, GetPrefixLen_007, Function | MediumTest | Level0)
2292 {
2293 std::vector<std::string> netmask = {"255", "255", "255"};
2294 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
2295 EXPECT_EQ(result, 24);
2296 }
2297
2298 /**
2299 * @tc.number JudgingDataActivateTimeOut_001
2300 * @tc.name test branch
2301 * @tc.desc Function test
2302 */
2303 HWTEST_F(BranchTest, JudgingDataActivateTimeOut_001, Function | MediumTest | Level0)
2304 {
2305 auto cellularDataHiSysEvent = DelayedSingleton<CellularDataHiSysEvent>::GetInstance();
2306 int32_t slotId = 1;
2307 int32_t switchState = 1;
2308 cellularDataHiSysEvent->dataActivateStartTime_ = -1000;
2309 cellularDataHiSysEvent->JudgingDataActivateTimeOut(slotId, switchState);
2310 cellularDataHiSysEvent->SetCellularDataActivateStartTime();
2311 EXPECT_NE(cellularDataHiSysEvent->dataActivateStartTime_, -1000);
2312 }
2313
2314 /**
2315 * @tc.number ReadMvnoApnResult_001
2316 * @tc.name Test the function
2317 * @tc.desc Function test
2318 */
2319 HWTEST_F(BranchTest, ReadMvnoApnResult_001, TestSize.Level3)
2320 {
2321 std::shared_ptr<DataShare::DataShareResultSet> result = nullptr;
2322 std::string mvnoDataFromSim = "mvnoDataFromSim";
2323 std::vector<PdpProfile> apnVec;
2324 CellularDataRdbHelper cellularDataRdbHelper;
2325 cellularDataRdbHelper.ReadMvnoApnResult(nullptr, mvnoDataFromSim, apnVec);
2326 ASSERT_TRUE(apnVec.empty());
2327 }
2328
2329 /**
2330 * @tc.number ReadMvnoApnResult_002
2331 * @tc.name Test the function
2332 * @tc.desc Function test
2333 */
2334 HWTEST_F(BranchTest, ReadMvnoApnResult_002, TestSize.Level3)
2335 {
2336 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
2337 std::string mvnoDataFromSim = "mvnoDataFromSim";
2338 std::vector<PdpProfile> apnVec;
2339 CellularDataRdbHelper cellularDataRdbHelper;
2340 cellularDataRdbHelper.ReadMvnoApnResult(nullptr, mvnoDataFromSim, apnVec);
2341 ASSERT_TRUE(apnVec.empty());
2342 }
2343
2344 /**
2345 * @tc.number MakePdpProfile_001
2346 * @tc.name Test the function
2347 * @tc.desc Function test
2348 */
2349 HWTEST_F(BranchTest, MakePdpProfile_001, TestSize.Level3)
2350 {
2351 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
2352 int i = 0;
2353 PdpProfile apnBean;
2354 apnBean.pdpProtocol = "";
2355 apnBean.roamPdpProtocol = "";
2356 CellularDataRdbHelper cellularDataRdbHelper;
2357 cellularDataRdbHelper.MakePdpProfile(result, i, apnBean);
2358 ASSERT_EQ("IP", apnBean.pdpProtocol);
2359 ASSERT_EQ("IP", apnBean.roamPdpProtocol);
2360 }
2361
2362 /**
2363 * @tc.number MakePdpProfile_002
2364 * @tc.name Test the function
2365 * @tc.desc Function test
2366 */
2367 HWTEST_F(BranchTest, MakePdpProfile_002, TestSize.Level3)
2368 {
2369 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
2370 int i = 0;
2371 PdpProfile apnBean;
2372 apnBean.pdpProtocol = "ABC";
2373 apnBean.roamPdpProtocol = "abc";
2374 CellularDataRdbHelper cellularDataRdbHelper;
2375 cellularDataRdbHelper.MakePdpProfile(result, i, apnBean);
2376 ASSERT_EQ("ABC", apnBean.pdpProtocol);
2377 ASSERT_EQ("abc", apnBean.roamPdpProtocol);
2378 }
2379
2380 /**
2381 * @tc.number WriteEventCellularRequest_Test_01
2382 * @tc.name test error branch
2383 * @tc.desc Function test
2384 */
2385 HWTEST_F(BranchTest, WriteEventCellularRequest_Test_01, TestSize.Level3)
2386 {
2387 CellularDataUtils::ParseNormalIpAddr(ADDRESS);
2388 CellularDataUtils::ParseRoute(ADDRESS);
2389 CellularDataUtils::GetPrefixLen(ADDRESS, FLAG);
2390 auto cellularDataHiSysEvent = DelayedSingleton<CellularDataHiSysEvent>::GetInstance();
2391 cellularDataHiSysEvent->WriteCellularRequestBehaviorEvent(1, "abc", 1, 1);
2392 CellularDataController controller { 0 };
2393 controller.Init();
2394 NetRequest request;
2395 int32_t state = 0;
2396 ASSERT_FALSE(controller.cellularDataHandler_->WriteEventCellularRequest(request, state));
2397 request.capability = NetCap::NET_CAPABILITY_INTERNET;
2398 ASSERT_FALSE(controller.cellularDataHandler_->WriteEventCellularRequest(request, state));
2399 request.bearTypes |= (1ULL << NetBearType::BEARER_CELLULAR);
2400 ASSERT_TRUE(controller.cellularDataHandler_->WriteEventCellularRequest(request, state));
2401 request.capability = NetCap::NET_CAPABILITY_END;
2402 ASSERT_FALSE(controller.cellularDataHandler_->WriteEventCellularRequest(request, state));
2403 }
2404
2405 /**
2406 * @tc.number IsSupportDunApn_001
2407 * @tc.name test error branch
2408 * @tc.desc Function test
2409 */
2410 HWTEST_F(BranchTest, IsSupportDunApn_001, Function | MediumTest | Level1)
2411 {
2412 CellularDataController controller { 0 };
2413 EXPECT_FALSE(controller.IsSupportDunApn());
2414 controller.Init();
2415 controller.cellularDataHandler_->apnManager_ = nullptr;
2416 EXPECT_FALSE(controller.IsSupportDunApn());
2417 }
2418
2419 /**
2420 * @tc.number CellularDataConnectionManager_003
2421 * @tc.name test error branch
2422 * @tc.desc Function test
2423 */
2424 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_003, Function | MediumTest | Level3)
2425 {
2426 DataConnectionManager con { 0 };
2427 con.Init();
2428 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
2429 std::shared_ptr<CellularDataStateMachine> stateMachine = machine->CreateCellularDataConnect(0);
2430 con.AddConnectionStateMachine(stateMachine);
2431 con.RemoveConnectionStateMachine(stateMachine);
2432 con.AddActiveConnectionByCid(stateMachine);
2433 con.GetActiveConnectionByCid(1);
2434 con.GetAllConnectionMachine();
2435 con.StartStallDetectionTimer();
2436 con.StopStallDetectionTimer();
2437 con.RegisterRadioObserver();
2438 con.UnRegisterRadioObserver();
2439 con.uplinkUseLte_ = true;
2440 con.UpdateBandWidthsUseLte();
2441 con.GetActiveConnection();
2442 con.IsBandwidthSourceModem();
2443 ASSERT_NE(-1, con.GetDataRecoveryState());
2444 con.IsNeedDoRecovery(true);
2445 con.GetActiveConnectionByCid(0);
2446 con.isNoActiveConnection();
2447 auto event = AppExecFwk::InnerEvent::Get(0);
2448 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
2449 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
2450 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NETWORKSLICE_URSP_RPT);
2451 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
2452 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NETWORKSLICE_ALLOWEDNSSAI_RPT);
2453 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
2454 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NETWORKSLICE_EHPLMN_RPT);
2455 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
2456 event = AppExecFwk::InnerEvent::Get(0);
2457 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
2458 ccmDefaultState.RadioDataCallListChanged(event);
2459 ccmDefaultState.UpdateNetworkInfo(event);
2460 ccmDefaultState.RadioLinkCapabilityChanged(event);
2461 ccmDefaultState.RadioNetworkSliceUrspRpt(event);
2462 ccmDefaultState.RadioNetworkSliceAllowedNssaiRpt(event);
2463 ccmDefaultState.RadioNetworkSliceEhplmnRpt(event);
2464 con.GetDataFlowType();
2465 con.GetDefaultBandWidthsConfig();
2466 con.GetDefaultTcpBufferConfig();
2467 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
2468 con.UpdateCallState(0);
2469 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
2470 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
2471 }
2472
2473 /**
2474 * @tc.number DataConnectionMonitor_003
2475 * @tc.name test error branch
2476 * @tc.desc Function test
2477 */
2478 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_004, Function | MediumTest | Level3)
2479 {
2480 DataConnectionManager con { 0 };
2481 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
2482 con.connectionMonitor_->UpdateFlowInfo();
2483 con.connectionMonitor_->UpdateCallState(0);
2484 con.connectionMonitor_->OnStallDetectionTimer();
2485 con.connectionMonitor_->StopStallDetectionTimer();
2486 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
2487 con.connectionMonitor_->HandleRecovery();
2488 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
2489 con.connectionMonitor_->HandleRecovery();
2490 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
2491 con.connectionMonitor_->HandleRecovery();
2492 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
2493 con.connectionMonitor_->HandleRecovery();
2494 con.connectionMonitor_->BeginNetStatistics();
2495 con.connectionMonitor_->EndNetStatistics();
2496 con.connectionMonitor_->HandleScreenStateChanged(true);
2497 con.connectionMonitor_->UpdateNetTrafficState();
2498 auto event = AppExecFwk::InnerEvent::Get(0);
2499 con.connectionMonitor_->SetPreferredNetworkPara(event);
2500 con.connectionMonitor_->UpdateDataFlowType();
2501 con.connectionMonitor_->ProcessEvent(event);
2502 event = nullptr;
2503 con.connectionMonitor_->ProcessEvent(event);
2504 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
2505 }
2506
2507 /**
2508 * @tc.number DataConnectionMonitor_004
2509 * @tc.name test error branch
2510 * @tc.desc Function test
2511 */
2512 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_005, Function | MediumTest | Level3)
2513 {
2514 DataConnectionManager con { 0 };
2515 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
2516 con.connectionMonitor_->UpdateFlowInfo();
2517 con.connectionMonitor_->UpdateCallState(0);
2518 con.connectionMonitor_->OnStallDetectionTimer();
2519 con.connectionMonitor_->StopStallDetectionTimer();
2520 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
2521 con.connectionMonitor_->HandleRecovery();
2522 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
2523 con.connectionMonitor_->HandleRecovery();
2524 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
2525 con.connectionMonitor_->HandleRecovery();
2526 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
2527 con.connectionMonitor_->HandleRecovery();
2528 con.connectionMonitor_->BeginNetStatistics();
2529 con.connectionMonitor_->BeginNetStatistics();
2530 con.connectionMonitor_->HandleScreenStateChanged(true);
2531 con.connectionMonitor_->UpdateNetTrafficState();
2532 auto event = AppExecFwk::InnerEvent::Get(0);
2533 con.connectionMonitor_->SetPreferredNetworkPara(event);
2534 con.connectionMonitor_->UpdateDataFlowType();
2535 con.connectionMonitor_->ProcessEvent(event);
2536 event = nullptr;
2537 con.connectionMonitor_->ProcessEvent(event);
2538 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
2539 }
2540
2541 /**
2542 * @tc.number ParseIpAddr_006
2543 * @tc.name test branch
2544 * @tc.desc Function test
2545 */
2546 HWTEST_F(BranchTest, ParseIpAddr_006, Function | MediumTest | Level0)
2547 {
2548 std::string address = "192.168.1.1 ";
2549 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
2550 EXPECT_EQ(ipInfoArray.size(), 1);
2551 }
2552
2553 /**
2554 * @tc.number ParseNormalIpAddrTest001
2555 * @tc.name test branch
2556 * @tc.desc Function test
2557 */
2558 HWTEST_F(BranchTest, ParseNormalIpAddrTest001, Function | MediumTest | Level0)
2559 {
2560 std::string address = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
2561 auto result = CellularDataUtils::ParseNormalIpAddr(address);
2562 EXPECT_EQ(result.size(), 1);
2563 }
2564
2565 /**
2566 * @tc.number ParseRouteTest001
2567 * @tc.name test branch
2568 * @tc.desc Function test
2569 */
2570 HWTEST_F(BranchTest, ParseRouteTest001, Function | MediumTest | Level0)
2571 {
2572 std::string address = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
2573 auto result = CellularDataUtils::ParseRoute(address);
2574 EXPECT_EQ(result.size(), 1);
2575 }
2576
2577 /**
2578 * @tc.number SplitTest001
2579 * @tc.name test branch
2580 * @tc.desc Function test
2581 */
2582 HWTEST_F(BranchTest, SplitTest001, Function | MediumTest | Level0)
2583 {
2584 std::string input = "hello_world_";
2585 std::string flag = "_";
2586 std::string address = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
2587 auto result = CellularDataUtils::Split(input, flag);
2588 EXPECT_EQ(result.size(), 2);
2589 }
2590
2591 /**
2592 * @tc.number MarshallingTest001
2593 * @tc.name test branch
2594 * @tc.desc Function test
2595 */
2596 HWTEST_F(BranchTest, MarshallingTest001, Function | MediumTest | Level0)
2597 {
2598 ApnAttribute apnAttr;
2599 Parcel parcel;
2600 auto result = apnAttr.Marshalling(parcel);
2601 EXPECT_TRUE(result);
2602 }
2603 } // namespace Telephony
2604 } // namespace OHOS
2605