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_service_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 "data_access_token.h"
40 #include "data_connection_manager.h"
41 #include "data_connection_monitor.h"
42 #include "datashare_result_set.h"
43 #include "default.h"
44 #include "disconnecting.h"
45 #include "gtest/gtest.h"
46 #include "inactive.h"
47 #include "incall_data_state_machine.h"
48 #include "net_manager_call_back.h"
49 #include "net_manager_tactics_call_back.h"
50 #include "network_search_callback.h"
51 #include "pdp_profile_data.h"
52 #include "state_notification.h"
53 #include "telephony_errors.h"
54 #include "telephony_hisysevent.h"
55 #include "telephony_log_wrapper.h"
56 #include "uri.h"
57 #include "core_service_client.h"
58
59 namespace OHOS {
60 namespace Telephony {
61 using namespace testing::ext;
62
63 namespace {
64 const int32_t INVALID_SLOTID = -1;
65 const int32_t INVALID_SLOTID_TWO = 5;
66 const int32_t INVALID_CID = -1;
67 const int32_t INVALID_FD = -1;
68 const int32_t DEFAULT_SIM_SLOT_ID = 0;
69 const int32_t SLEEP_TIME_SECONDS = 3;
70 const std::string ADDRESS = "127.0.0.1";
71 const std::string FLAG = ".";
72 } // namespace
73
74 class DemoHandler : public AppExecFwk::EventHandler {
75 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & runner)76 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &runner) : AppExecFwk::EventHandler(runner) {}
~DemoHandler()77 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)78 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
79 };
80
81 class BranchTest : public testing::Test {
82 public:
83 static void SetUpTestCase();
84 static void TearDownTestCase();
85 static bool HasSimCard(const int32_t slotId);
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() {}
HasSimCard(const int32_t slotId)96 bool BranchTest::HasSimCard(const int32_t slotId)
97 {
98 bool hasSimCard = false;
99 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
100 return hasSimCard;
101 }
102
103 class StateMachineTest : public TelEventHandler {
104 public:
StateMachineTest()105 StateMachineTest() : TelEventHandler("StateMachineTest") {}
106 ~StateMachineTest() = default;
107 std::shared_ptr<CellularDataStateMachine> CreateCellularDataConnect(int32_t slotId);
108
109 public:
110 std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine_ = nullptr;
111 };
112
CreateCellularDataConnect(int32_t slotId)113 std::shared_ptr<CellularDataStateMachine> StateMachineTest::CreateCellularDataConnect(int32_t slotId)
114 {
115 if (cellularDataStateMachine_ != nullptr) {
116 return cellularDataStateMachine_;
117 }
118 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(slotId).release();
119 if (connectionManager == nullptr) {
120 return nullptr;
121 }
122 connectionManager->Init();
123 cellularDataStateMachine_ = std::make_shared<CellularDataStateMachine>(
124 connectionManager, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
125 return cellularDataStateMachine_;
126 }
127
128 class IncallStateMachineTest : public TelEventHandler {
129 public:
IncallStateMachineTest()130 IncallStateMachineTest() : TelEventHandler("IncallStateMachineTest") {}
131 ~IncallStateMachineTest() = default;
132 std::shared_ptr<IncallDataStateMachine> CreateIncallDataStateMachine(int32_t slotId);
133
134 public:
135 std::shared_ptr<IncallDataStateMachine> incallStateMachine_ = nullptr;
136 };
137
CreateIncallDataStateMachine(int32_t slotId)138 std::shared_ptr<IncallDataStateMachine> IncallStateMachineTest::CreateIncallDataStateMachine(int32_t slotId)
139 {
140 if (incallStateMachine_ != nullptr) {
141 return incallStateMachine_;
142 }
143 sptr<ApnManager> apnManager = std::make_unique<ApnManager>().release();
144 if (apnManager == nullptr) {
145 return nullptr;
146 }
147 incallStateMachine_ = std::make_shared<IncallDataStateMachine>(slotId,
148 std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())), apnManager);
149 return incallStateMachine_;
150 }
151
152 /**
153 * @tc.number Telephony_CellularDataHandler_001
154 * @tc.name test error branch
155 * @tc.desc Function test
156 */
157 HWTEST_F(BranchTest, Telephony_CellularDataHandler_001, Function | MediumTest | Level1)
158 {
159 EventFwk::MatchingSkills matchingSkills;
160 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
161 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
162 CellularDataHandler cellularDataHandler { subscriberInfo, 0 };
163 cellularDataHandler.HandleSimStateChanged();
164 cellularDataHandler.ReleaseAllNetworkRequest();
165 cellularDataHandler.CreateApnItem();
166 auto event = AppExecFwk::InnerEvent::Get(0);
167 event = nullptr;
168 cellularDataHandler.ProcessEvent(event);
169 EventFwk::CommonEventData data;
170 cellularDataHandler.OnReceiveEvent(data);
171 ASSERT_NE(cellularDataHandler.SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
172 bool dataEnaled = false;
173 cellularDataHandler.IsCellularDataEnabled(dataEnaled);
174 ASSERT_FALSE(dataEnaled);
175 bool dataRoamingEnabled = false;
176 cellularDataHandler.IsCellularDataRoamingEnabled(dataRoamingEnabled);
177 ASSERT_FALSE(dataRoamingEnabled);
178 ASSERT_NE(cellularDataHandler.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
179 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState());
180 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState(""));
181 sptr<ApnHolder> apnHolder;
182 DisConnectionReason reason = cellularDataHandler.GetDisConnectionReason();
183 cellularDataHandler.ClearConnection(apnHolder, reason);
184 cellularDataHandler.EstablishAllApnsIfConnectable();
185 cellularDataHandler.ClearAllConnections(reason);
186 cellularDataHandler.GetSlotId();
187 ASSERT_FALSE(cellularDataHandler.HandleApnChanged());
188 cellularDataHandler.HandleApnChanged(event);
189 cellularDataHandler.GetCellularDataFlowType();
190 cellularDataHandler.SetPolicyDataOn(true);
191 ASSERT_FALSE(cellularDataHandler.IsRestrictedMode());
192 cellularDataHandler.GetDisConnectionReason();
193 ASSERT_FALSE(cellularDataHandler.HasInternetCapability(0));
194 ASSERT_EQ(nullptr, cellularDataHandler.FindIdleCellularDataConnection());
195 cellularDataHandler.AttemptEstablishDataConnection(apnHolder);
196 ASSERT_FALSE(cellularDataHandler.CheckAttachAndSimState(apnHolder));
197 ASSERT_FALSE(cellularDataHandler.CheckRoamingState(apnHolder));
198 ASSERT_FALSE(cellularDataHandler.CheckApnState(apnHolder));
199 cellularDataHandler.RemoveAllEvents();
200 sleep(SLEEP_TIME_SECONDS);
201 }
202
203 /**
204 * @tc.number Telephony_CellularDataHandler_002
205 * @tc.name test error branch
206 * @tc.desc Function test
207 */
208 HWTEST_F(BranchTest, Telephony_CellularDataHandler_002, Function | MediumTest | Level1)
209 {
210 EventFwk::MatchingSkills matchingSkills;
211 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
212 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
213 CellularDataHandler cellularDataHandler { subscriberInfo, 0 };
214 auto event = AppExecFwk::InnerEvent::Get(0);
215 event = nullptr;
216 sptr<ApnHolder> apnHolder;
217 ApnItem::Attribute apnAttr;
218 cellularDataHandler.RadioPsConnectionAttached(event);
219 cellularDataHandler.RadioPsConnectionDetached(event);
220 cellularDataHandler.RoamingStateOn(event);
221 cellularDataHandler.RoamingStateOff(event);
222 cellularDataHandler.EstablishDataConnectionComplete(event);
223 cellularDataHandler.DisconnectDataComplete(event);
224 cellularDataHandler.MsgEstablishDataConnection(event);
225 cellularDataHandler.MsgRequestNetwork(event);
226 cellularDataHandler.HandleSettingSwitchChanged(event);
227 cellularDataHandler.HandleDBSettingIncallChanged(event);
228 cellularDataHandler.HandleDefaultDataSubscriptionChanged();
229 cellularDataHandler.IncallDataComplete(event);
230 cellularDataHandler.HandleCallChanged(0);
231 cellularDataHandler.HandleImsCallChanged(0);
232 cellularDataHandler.HandleVoiceCallChanged(0);
233 cellularDataHandler.HandleSimStateOrRecordsChanged(event);
234 cellularDataHandler.HandleSimAccountLoaded(event);
235 cellularDataHandler.HandleRadioStateChanged(event);
236 cellularDataHandler.HandleDsdsModeChanged(event);
237 cellularDataHandler.SetRilAttachApnResponse(event);
238 cellularDataHandler.GetDefaultConfiguration();
239 cellularDataHandler.GetDefaultDataRoamingConfig();
240 cellularDataHandler.HandleRadioNrStateChanged(event);
241 cellularDataHandler.HandleRadioNrFrequencyChanged(event);
242 cellularDataHandler.HandleDBSettingEnableChanged(event);
243 cellularDataHandler.HandleDBSettingRoamingChanged(event);
244 cellularDataHandler.SetDataPermittedResponse(event);
245 cellularDataHandler.OnRilAdapterHostDied(event);
246 cellularDataHandler.OnCleanAllDataConnectionsDone(event);
247 cellularDataHandler.RegisterDataSettingObserver();
248 cellularDataHandler.UnRegisterDataSettingObserver();
249 cellularDataHandler.GetDataConnApnAttr(apnAttr);
250 cellularDataHandler.HandleFactoryReset(event);
251 ASSERT_FALSE(cellularDataHandler.HasAnyHigherPriorityConnection(apnHolder));
252 cellularDataHandler.RemoveAllEvents();
253 sleep(SLEEP_TIME_SECONDS);
254 }
255
256 /**
257 * @tc.number Telephony_CellularDataHandler_003
258 * @tc.name test error branch
259 * @tc.desc Function test
260 */
261 HWTEST_F(BranchTest, Telephony_CellularDataHandler_003, Function | MediumTest | Level3)
262 {
263 EventFwk::MatchingSkills matchingSkills;
264 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
265 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
266 CellularDataHandler cellularDataHandler { subscriberInfo, INVALID_SLOTID };
267 cellularDataHandler.apnManager_ = std::make_unique<ApnManager>().release();
268 cellularDataHandler.SetDataPermittedForMms(false);
269 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
270 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
271 cellularDataHandler.ClearConnection(apnHolder, reason);
272 cellularDataHandler.EstablishAllApnsIfConnectable();
273 cellularDataHandler.ClearAllConnections(reason);
274 cellularDataHandler.ChangeConnectionForDsds(false);
275 cellularDataHandler.ChangeConnectionForDsds(true);
276 cellularDataHandler.connectionManager_ = std::make_unique<DataConnectionManager>(INVALID_SLOTID).release();
277 cellularDataHandler.ClearAllConnections(reason);
278 cellularDataHandler.EstablishAllApnsIfConnectable();
279 cellularDataHandler.UpdatePhysicalConnectionState(true);
280 cellularDataHandler.ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
281 ASSERT_FALSE(cellularDataHandler.CheckApnState(apnHolder));
282 cellularDataHandler.AttemptEstablishDataConnection(apnHolder);
283 cellularDataHandler.connectionManager_ = nullptr;
284 auto event = AppExecFwk::InnerEvent::Get(0);
285 cellularDataHandler.ClearConnectionIfRequired();
286 event = nullptr;
287 cellularDataHandler.MsgEstablishDataConnection(event);
288 ASSERT_FALSE(cellularDataHandler.HasAnyHigherPriorityConnection(apnHolder));
289 cellularDataHandler.connectionManager_ = std::make_unique<DataConnectionManager>(INVALID_SLOTID).release();
290 ASSERT_FALSE(cellularDataHandler.HasInternetCapability(INVALID_CID));
291 ASSERT_EQ(cellularDataHandler.GetDataRecoveryState(), 0);
292 cellularDataHandler.DisconnectDataComplete(event);
293 std::string str = "";
294 ASSERT_EQ(cellularDataHandler.GetDataConnIpType(), str);
295 cellularDataHandler.apnManager_ = nullptr;
296 ASSERT_EQ(cellularDataHandler.GetDataConnIpType(), str);
297 cellularDataHandler.CheckForCompatibleDataConnection(apnHolder);
298 event = AppExecFwk::InnerEvent::Get(0);
299 cellularDataHandler.HandleDBSettingRoamingChanged(event);
300 cellularDataHandler.ClearConnectionIfRequired();
301 ASSERT_EQ(nullptr, cellularDataHandler.FindIdleCellularDataConnection());
302 cellularDataHandler.RemoveAllEvents();
303 sleep(SLEEP_TIME_SECONDS);
304 }
305
306 /**
307 * @tc.number Telephony_CellularDataHandler_004
308 * @tc.name test error branch
309 * @tc.desc Function test
310 */
311 HWTEST_F(BranchTest, Telephony_CellularDataHandler_004, Function | MediumTest | Level1)
312 {
313 CellularDataController controller { 0 };
314 controller.Init();
315 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
316 auto event = AppExecFwk::InnerEvent::Get(0);
317 event = nullptr;
318 controller.cellularDataHandler_->ProcessEvent(event);
319 controller.cellularDataHandler_->PsDataRatChanged(event);
320 ApnItem::Attribute apnAttr;
321 controller.cellularDataHandler_->GetDataConnApnAttr(apnAttr);
322 EventFwk::CommonEventData data;
323 controller.cellularDataHandler_->OnReceiveEvent(data);
324 ASSERT_EQ(controller.cellularDataHandler_->SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
325 bool dataEnaled = false;
326 controller.cellularDataHandler_->IsCellularDataEnabled(dataEnaled);
327 bool dataRoamingEnabled = false;
328 controller.cellularDataHandler_->IsCellularDataRoamingEnabled(dataRoamingEnabled);
329 ASSERT_NE(controller.cellularDataHandler_->SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
330 controller.cellularDataHandler_->CreateCellularDataConnect();
331 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, controller.cellularDataHandler_->GetCellularDataState());
332 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, controller.cellularDataHandler_->GetCellularDataState(""));
333 sptr<ApnHolder> apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
334 DisConnectionReason reason = controller.cellularDataHandler_->GetDisConnectionReason();
335 controller.cellularDataHandler_->ClearConnection(apnHolder, reason);
336 controller.cellularDataHandler_->EstablishAllApnsIfConnectable();
337 controller.cellularDataHandler_->ClearAllConnections(reason);
338 controller.cellularDataHandler_->GetSlotId();
339 ASSERT_TRUE(controller.cellularDataHandler_->HandleApnChanged());
340 controller.cellularDataHandler_->HandleApnChanged(event);
341 controller.cellularDataHandler_->GetCellularDataFlowType();
342 controller.cellularDataHandler_->SetPolicyDataOn(true);
343 ASSERT_FALSE(controller.cellularDataHandler_->IsRestrictedMode());
344 controller.cellularDataHandler_->GetDisConnectionReason();
345 ASSERT_FALSE(controller.cellularDataHandler_->HasInternetCapability(0));
346 ASSERT_EQ(nullptr, controller.cellularDataHandler_->FindIdleCellularDataConnection());
347 controller.cellularDataHandler_->AttemptEstablishDataConnection(apnHolder);
348 controller.cellularDataHandler_->EstablishDataConnection(apnHolder, 1);
349 controller.cellularDataHandler_->CheckRoamingState(apnHolder);
350 controller.cellularDataHandler_->CheckApnState(apnHolder);
351 ASSERT_FALSE(controller.cellularDataHandler_->CheckAttachAndSimState(apnHolder));
352 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
353 controller.cellularDataHandler_->RemoveAllEvents();
354 sleep(SLEEP_TIME_SECONDS);
355 }
356
357 /**
358 * @tc.number Telephony_CellularDataHandler_005
359 * @tc.name test error branch
360 * @tc.desc Function test
361 */
362 HWTEST_F(BranchTest, Telephony_CellularDataHandler_005, Function | MediumTest | Level1)
363 {
364 CellularDataController controller { 0 };
365 controller.Init();
366 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
367 auto event = AppExecFwk::InnerEvent::Get(0);
368 controller.cellularDataHandler_->RadioPsConnectionAttached(event);
369 controller.cellularDataHandler_->RadioPsConnectionDetached(event);
370 controller.cellularDataHandler_->RoamingStateOn(event);
371 controller.cellularDataHandler_->RoamingStateOff(event);
372 controller.cellularDataHandler_->EstablishDataConnectionComplete(event);
373 controller.cellularDataHandler_->MsgEstablishDataConnection(event);
374 controller.cellularDataHandler_->MsgRequestNetwork(event);
375 controller.cellularDataHandler_->HandleSettingSwitchChanged(event);
376 controller.cellularDataHandler_->HandleDBSettingIncallChanged(event);
377 controller.cellularDataHandler_->HandleDefaultDataSubscriptionChanged();
378 controller.cellularDataHandler_->IncallDataComplete(event);
379 controller.cellularDataHandler_->HandleCallChanged(0);
380 controller.cellularDataHandler_->HandleImsCallChanged(0);
381 controller.cellularDataHandler_->HandleVoiceCallChanged(0);
382 controller.cellularDataHandler_->HandleSimStateOrRecordsChanged(event);
383 controller.cellularDataHandler_->HandleSimAccountLoaded(event);
384 controller.cellularDataHandler_->HandleRadioStateChanged(event);
385 controller.cellularDataHandler_->HandleDsdsModeChanged(event);
386 controller.cellularDataHandler_->SetRilAttachApnResponse(event);
387 controller.cellularDataHandler_->GetDefaultConfiguration();
388 controller.cellularDataHandler_->HandleRadioNrStateChanged(event);
389 controller.cellularDataHandler_->HandleRadioNrFrequencyChanged(event);
390 controller.cellularDataHandler_->HandleDBSettingEnableChanged(event);
391 controller.cellularDataHandler_->HandleDBSettingRoamingChanged(event);
392 controller.cellularDataHandler_->SetDataPermittedResponse(event);
393 controller.cellularDataHandler_->OnRilAdapterHostDied(event);
394 controller.cellularDataHandler_->OnCleanAllDataConnectionsDone(event);
395 controller.cellularDataHandler_->HandleFactoryReset(event);
396 controller.cellularDataHandler_->PsDataRatChanged(event);
397 sptr<ApnHolder> apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
398 ASSERT_FALSE(controller.cellularDataHandler_->HasAnyHigherPriorityConnection(apnHolder));
399 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
400 controller.cellularDataHandler_->RemoveAllEvents();
401 sleep(SLEEP_TIME_SECONDS);
402 }
403
404 /**
405 * @tc.number Telephony_CellularDataHandler_006
406 * @tc.name test error branch
407 * @tc.desc Function test
408 */
409 HWTEST_F(BranchTest, Telephony_CellularDataHandler_006, Function | MediumTest | Level3)
410 {
411 EventFwk::MatchingSkills matchingSkills;
412 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
413 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
414 CellularDataHandler cellularDataHandler { subscriberInfo, 0 };
415 auto event = AppExecFwk::InnerEvent::Get(0);
416 event = nullptr;
417 cellularDataHandler.apnManager_ = std::make_unique<ApnManager>().release();
418 sptr<ApnHolder> apnHolder;
419 std::string str = "";
420 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState());
421 cellularDataHandler.CheckForCompatibleDataConnection(apnHolder);
422 cellularDataHandler.PsRadioEmergencyStateOpen(event);
423 cellularDataHandler.PsRadioEmergencyStateClose(event);
424 cellularDataHandler.IsNeedDoRecovery(true);
425 cellularDataHandler.HandleSortConnection();
426 ASSERT_EQ(cellularDataHandler.IsSingleConnectionEnabled(1), true);
427 ASSERT_EQ(cellularDataHandler.GetDataConnIpType(), str);
428 ASSERT_EQ(cellularDataHandler.GetDataRecoveryState(), -1);
429 ASSERT_FALSE(cellularDataHandler.IsGsm());
430 ASSERT_FALSE(cellularDataHandler.IsCdma());
431 cellularDataHandler.lastCallState_ = 0;
432 cellularDataHandler.HandleCallChanged(0);
433 cellularDataHandler.dataSwitchSettings_ = nullptr;
434 ASSERT_NE(cellularDataHandler.SetIntelligenceSwitchEnable(true), TELEPHONY_ERR_SUCCESS);
435 cellularDataHandler.RemoveAllEvents();
436 sleep(SLEEP_TIME_SECONDS);
437 }
438
439 /**
440 * @tc.number Telephony_CellularDataHandler_007
441 * @tc.name test error branch
442 * @tc.desc Function test
443 */
444 HWTEST_F(BranchTest, Telephony_CellularDataHandler_007, Function | MediumTest | Level1)
445 {
446 CellularDataController controller { 0 };
447 controller.Init();
448 ASSERT_FALSE(controller.cellularDataHandler_ == nullptr);
449 auto event = AppExecFwk::InnerEvent::Get(0);
450 sptr<ApnHolder> apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1);
451 std::string str = "";
452 controller.cellularDataHandler_->CheckForCompatibleDataConnection(apnHolder);
453 controller.cellularDataHandler_->PsRadioEmergencyStateOpen(event);
454 controller.cellularDataHandler_->PsRadioEmergencyStateClose(event);
455 controller.cellularDataHandler_->IsNeedDoRecovery(true);
456 controller.cellularDataHandler_->CreateIncallDataStateMachine(1);
457 controller.cellularDataHandler_->HandleSettingSwitchChanged(event);
458 ASSERT_TRUE(controller.cellularDataHandler_->SetDataPermittedForMms(true));
459 controller.cellularDataHandler_->IncallDataComplete(event);
460 controller.cellularDataHandler_->HandleImsCallChanged(0);
461 controller.cellularDataHandler_->HandleSortConnection();
462 ASSERT_EQ(controller.cellularDataHandler_->IsSingleConnectionEnabled(1), false);
463 ASSERT_EQ(controller.cellularDataHandler_->GetDataConnIpType(), str);
464 ASSERT_NE(controller.cellularDataHandler_->GetDataRecoveryState(), -1);
465 ASSERT_FALSE(controller.cellularDataHandler_->IsGsm());
466 ASSERT_FALSE(controller.cellularDataHandler_->IsCdma());
467 ASSERT_EQ(controller.cellularDataHandler_->SetIntelligenceSwitchEnable(true), TELEPHONY_ERR_SUCCESS);
468 controller.cellularDataHandler_->ClearConnectionIfRequired();
469 controller.cellularDataHandler_->RemoveAllEvents();
470 sleep(SLEEP_TIME_SECONDS);
471 }
472
473 /**
474 * @tc.number Telephony_CellularDataService_001
475 * @tc.name test error branch
476 * @tc.desc Function test
477 */
478 HWTEST_F(BranchTest, Telephony_CellularDataService_001, Function | MediumTest | Level3)
479 {
480 if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
481 return;
482 }
483 DataAccessToken token;
484 CellularDataService service;
485 std::vector<std::u16string> strV;
486 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
487 service.state_ = ServiceRunningState::STATE_RUNNING;
488 service.OnStart();
489 service.InitModule();
490 bool dataEnabled = false;
491 bool dataRoamingEnabled = false;
492 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataEnabled(dataEnabled));
493 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
494 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
495 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataState());
496 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(INVALID_SLOTID, dataRoamingEnabled));
497 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(INVALID_SLOTID, false));
498 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(DEFAULT_SIM_SLOT_ID, dataRoamingEnabled));
499 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(DEFAULT_SIM_SLOT_ID, true));
500 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(INVALID_SLOTID));
501 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(DEFAULT_SIM_SLOT_ID));
502 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDefaultCellularDataSlotId());
503 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(INVALID_SLOTID));
504 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(DEFAULT_SIM_SLOT_ID));
505 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataFlowType());
506 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(INVALID_SLOTID, 0));
507 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(DEFAULT_SIM_SLOT_ID, 0));
508 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(INVALID_SLOTID));
509 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(DEFAULT_SIM_SLOT_ID));
510 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
511 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(INVALID_SLOTID, reason));
512 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(DEFAULT_SIM_SLOT_ID, reason));
513 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(INVALID_SLOTID, false));
514 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, false));
515 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, true));
516 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(INVALID_SLOTID, false));
517 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(DEFAULT_SIM_SLOT_ID, false));
518 NetRequest request;
519 request.ident = "simId12";
520 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.RequestNet(request));
521 request.ident = "simId2";
522 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ReleaseNet(request));
523 ASSERT_FALSE(service.GetCellularDataController(DEFAULT_SIM_SLOT_ID) != nullptr);
524 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID) != nullptr);
525 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID_TWO) != nullptr);
526 }
527
528 /**
529 * @tc.number Telephony_CellularDataService_002
530 * @tc.name test error branch
531 * @tc.desc Function test
532 */
533 HWTEST_F(BranchTest, Telephony_CellularDataService_002, Function | MediumTest | Level3)
534 {
535 if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
536 return;
537 }
538 CellularDataService service;
539 std::vector<std::u16string> strV;
540 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
541 service.state_ = ServiceRunningState::STATE_RUNNING;
542 service.OnStart();
543 service.InitModule();
544 bool dataEnabled = false;
545 bool dataRoamingEnabled = false;
546 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataEnabled(dataEnabled));
547 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(false));
548 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(true));
549 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
550 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataState());
551 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(INVALID_SLOTID, dataRoamingEnabled));
552 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(INVALID_SLOTID, false));
553 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(INVALID_SLOTID));
554 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDefaultCellularDataSlotId());
555 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(INVALID_SLOTID));
556 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataFlowType());
557 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(INVALID_SLOTID, 0));
558 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(INVALID_SLOTID));
559 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
560 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(INVALID_SLOTID, reason));
561 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(INVALID_SLOTID, false));
562 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(INVALID_SLOTID, false));
563 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID) != nullptr);
564 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID_TWO) != nullptr);
565 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(DEFAULT_SIM_SLOT_ID, std::string()));
566 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(INVALID_SLOTID, std::string()));
567 ASSERT_EQ(service.GetDataRecoveryState(), 0);
568 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(2));
569 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(INVALID_SLOTID));
570 service.GetFlowDataInfoDump();
571 service.OnStop();
572 }
573
574 /**
575 * @tc.number Telephony_CellularDataService_003
576 * @tc.name test error branch
577 * @tc.desc Function test
578 */
579 HWTEST_F(BranchTest, Telephony_CellularDataService_003, Function | MediumTest | Level3)
580 {
581 DataAccessToken token;
582 CellularDataService service;
583 std::vector<std::u16string> strV;
584 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
585 service.state_ = ServiceRunningState::STATE_RUNNING;
586 service.OnStart();
587 service.InitModule();
588 service.cellularDataControllers_.clear();
589 bool dataEnabled = false;
590 bool dataRoamingEnabled = false;
591 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataEnabled(dataEnabled));
592 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
593 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(true));
594 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(INVALID_SLOTID, false));
595 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(DEFAULT_SIM_SLOT_ID, dataRoamingEnabled));
596 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(DEFAULT_SIM_SLOT_ID, true));
597 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataState());
598 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(INVALID_SLOTID, dataRoamingEnabled));
599 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(INVALID_SLOTID));
600 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(DEFAULT_SIM_SLOT_ID));
601 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(INVALID_SLOTID));
602 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(DEFAULT_SIM_SLOT_ID));
603 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataFlowType());
604 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(INVALID_SLOTID, 0));
605 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(DEFAULT_SIM_SLOT_ID, 0));
606 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDefaultCellularDataSlotId());
607 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(INVALID_SLOTID, false));
608 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(DEFAULT_SIM_SLOT_ID, false));
609 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(INVALID_SLOTID));
610 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(DEFAULT_SIM_SLOT_ID));
611 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
612 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(INVALID_SLOTID, reason));
613 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(DEFAULT_SIM_SLOT_ID, reason));
614 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(INVALID_SLOTID, false));
615 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, false));
616 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ChangeConnectionForDsds(DEFAULT_SIM_SLOT_ID, true));
617 NetRequest request;
618 request.ident = "simId12";
619 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.RequestNet(request));
620 request.ident = "simId2";
621 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ReleaseNet(request));
622 ASSERT_FALSE(service.GetCellularDataController(DEFAULT_SIM_SLOT_ID) != nullptr);
623 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID) != nullptr);
624 ASSERT_FALSE(service.GetCellularDataController(INVALID_SLOTID_TWO) != nullptr);
625 }
626
627 /**
628 * @tc.number Telephony_CellularDataService_004
629 * @tc.name test error branch
630 * @tc.desc Function test
631 */
632 HWTEST_F(BranchTest, Telephony_CellularDataService_004, Function | MediumTest | Level3)
633 {
634 if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
635 return;
636 }
637 DataAccessToken token;
638 CellularDataService service;
639 std::vector<std::u16string> strV;
640 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
641 service.state_ = ServiceRunningState::STATE_RUNNING;
642 service.OnStart();
643 service.InitModule();
644 service.GetFlowDataInfoDump();
645 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(false));
646 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(true));
647 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(DEFAULT_SIM_SLOT_ID, std::string()));
648 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(INVALID_SLOTID, std::string()));
649 ASSERT_EQ(service.GetDataRecoveryState(), 0);
650 ASSERT_EQ(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(2));
651 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(INVALID_SLOTID));
652 ApnItem::Attribute apnAttr;
653 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(INVALID_SLOTID, apnAttr));
654 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(DEFAULT_SIM_SLOT_ID, apnAttr));
655 std::string ipType;
656 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(INVALID_SLOTID, ipType));
657 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(DEFAULT_SIM_SLOT_ID, ipType));
658 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(INVALID_SLOTID, true));
659 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(DEFAULT_SIM_SLOT_ID, true));
660 }
661
662 /**
663 * @tc.number Telephony_CellularDataService_005
664 * @tc.name test error branch
665 * @tc.desc Function test
666 */
667 HWTEST_F(BranchTest, Telephony_CellularDataService_005, Function | MediumTest | Level3)
668 {
669 DataAccessToken token;
670 CellularDataService service;
671 std::vector<std::u16string> strV;
672 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
673 service.state_ = ServiceRunningState::STATE_RUNNING;
674 service.OnStart();
675 service.InitModule();
676 service.cellularDataControllers_.clear();
677 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(false));
678 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableIntelligenceSwitch(true));
679 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(DEFAULT_SIM_SLOT_ID, std::string()));
680 ASSERT_EQ(CELLULAR_DATA_INVALID_PARAM, service.GetApnState(INVALID_SLOTID, std::string()));
681 ASSERT_EQ(service.GetDataRecoveryState(), 0);
682 ASSERT_EQ(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(2));
683 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.InitCellularDataController(INVALID_SLOTID));
684 service.GetFlowDataInfoDump();
685 ApnItem::Attribute apnAttr;
686 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(INVALID_SLOTID, apnAttr));
687 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnApnAttr(DEFAULT_SIM_SLOT_ID, apnAttr));
688 std::string ipType;
689 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(INVALID_SLOTID, ipType));
690 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDataConnIpType(DEFAULT_SIM_SLOT_ID, ipType));
691 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(INVALID_SLOTID, true));
692 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsNeedDoRecovery(DEFAULT_SIM_SLOT_ID, true));
693 }
694
695 /**
696 * @tc.number CellularDataController_001
697 * @tc.name test error branch
698 * @tc.desc Function test
699 */
700 HWTEST_F(BranchTest, Telephony_CellularDataController_001, Function | MediumTest | Level3)
701 {
702 CellularDataController controller { 0 };
703 controller.RegisterEvents();
704 controller.Init();
705 controller.cellularDataHandler_ = nullptr;
706 NetRequest request;
707 ASSERT_FALSE(controller.ReleaseNet(request));
708 ASSERT_FALSE(controller.RequestNet(request));
709 ASSERT_NE(controller.SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
710 if (controller.systemAbilityListener_ != nullptr) {
711 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
712 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
713 controller.systemAbilityListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
714 controller.systemAbilityListener_->OnAddSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
715 controller.systemAbilityListener_->OnAddSystemAbility(0, "test");
716 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
717 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
718 controller.systemAbilityListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
719 controller.systemAbilityListener_->OnRemoveSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
720 controller.systemAbilityListener_->OnRemoveSystemAbility(0, "test");
721 }
722 bool dataEnabled = false;
723 controller.IsCellularDataEnabled(dataEnabled);
724 ASSERT_FALSE(dataEnabled);
725 controller.SetPolicyDataOn(true);
726 ASSERT_NE(controller.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
727 EXPECT_EQ(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState());
728 EXPECT_EQ(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState(""));
729 bool dataRoamingEnabled = false;
730 controller.IsCellularDataRoamingEnabled(dataRoamingEnabled);
731 ASSERT_FALSE(dataRoamingEnabled);
732 ASSERT_FALSE(controller.HandleApnChanged());
733 auto event = AppExecFwk::InnerEvent::Get(0);
734 controller.ProcessEvent(event);
735 event = nullptr;
736 controller.ProcessEvent(event);
737 controller.RegisterEvents();
738 ASSERT_FALSE(controller.IsRestrictedMode());
739 ASSERT_EQ(DisConnectionReason::REASON_NORMAL, controller.GetDisConnectionReason());
740 controller.HasInternetCapability(0);
741 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
742 ASSERT_FALSE(controller.ClearAllConnections(reason));
743 ASSERT_FALSE(controller.ChangeConnectionForDsds(false));
744 controller.UnRegisterEvents();
745 ASSERT_FALSE(controller.HandleApnChanged());
746 ASSERT_FALSE(controller.GetCellularDataFlowType());
747 }
748
749 /**
750 * @tc.number CellularDataController_002
751 * @tc.name test error branch
752 * @tc.desc Function test
753 */
754 HWTEST_F(BranchTest, Telephony_CellularDataController_002, Function | MediumTest | Level3)
755 {
756 CellularDataController controller { 0 };
757 controller.RegisterEvents();
758 controller.Init();
759 NetRequest request;
760 controller.ReleaseNet(request);
761 controller.RequestNet(request);
762 controller.SetCellularDataEnable(true);
763 controller.SetPolicyDataOn(true);
764 ASSERT_TRUE(controller.HandleApnChanged());
765 bool dataEnabled = false;
766 controller.IsCellularDataEnabled(dataEnabled);
767 ASSERT_TRUE(dataEnabled);
768 ASSERT_NE(controller.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
769 ASSERT_NE(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState());
770 ASSERT_NE(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState(""));
771 if (controller.systemAbilityListener_ != nullptr) {
772 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
773 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
774 controller.systemAbilityListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
775 controller.systemAbilityListener_->OnAddSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
776 controller.systemAbilityListener_->OnAddSystemAbility(0, "test");
777 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
778 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
779 controller.systemAbilityListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
780 controller.systemAbilityListener_->OnRemoveSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
781 controller.systemAbilityListener_->OnRemoveSystemAbility(0, "test");
782 }
783 bool dataRoamingEnabled = false;
784 controller.IsCellularDataRoamingEnabled(dataRoamingEnabled);
785 ASSERT_FALSE(dataRoamingEnabled);
786 ASSERT_TRUE(controller.HandleApnChanged());
787 auto event = AppExecFwk::InnerEvent::Get(0);
788 controller.ProcessEvent(event);
789 event = nullptr;
790 controller.ProcessEvent(event);
791 controller.RegisterEvents();
792 ASSERT_FALSE(controller.IsRestrictedMode());
793 ASSERT_EQ(DisConnectionReason::REASON_NORMAL, controller.GetDisConnectionReason());
794 controller.HasInternetCapability(0);
795 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
796 ASSERT_TRUE(controller.ClearAllConnections(reason));
797 controller.ChangeConnectionForDsds(false);
798 ASSERT_FALSE(controller.GetCellularDataFlowType());
799 controller.UnRegisterEvents();
800 if (controller.cellularDataHandler_ != nullptr) {
801 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
802 controller.cellularDataHandler_->RemoveAllEvents();
803 sleep(SLEEP_TIME_SECONDS);
804 }
805 }
806
807 /**
808 * @tc.number CellularDataController_003
809 * @tc.name test error branch
810 * @tc.desc Function test
811 */
812 HWTEST_F(BranchTest, Telephony_CellularDataController_003, Function | MediumTest | Level3)
813 {
814 CellularDataController controller { 0 };
815 controller.RegisterEvents();
816 controller.Init();
817 ApnItem::Attribute apnAttr;
818 controller.GetDataConnApnAttr(apnAttr);
819 std::string str = "";
820 ASSERT_EQ(controller.GetDataConnIpType(), str);
821 ASSERT_EQ(controller.GetDataRecoveryState(), 0);
822 controller.IsNeedDoRecovery(true);
823 controller.cellularDataHandler_ = nullptr;
824 controller.GetDataConnApnAttr(apnAttr);
825 ASSERT_EQ(controller.GetDataConnIpType(), str);
826 ASSERT_EQ(controller.GetDataRecoveryState(), 0);
827 controller.IsNeedDoRecovery(true);
828 }
829
830 /**
831 * @tc.number CellularDataConnectionManager_001
832 * @tc.name test error branch
833 * @tc.desc Function test
834 */
835 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_001, Function | MediumTest | Level3)
836 {
837 DataConnectionManager con { 0 };
838 con.Init();
839 con.connectionMonitor_ = nullptr;
840 con.ccmDefaultState_ = nullptr;
841 con.stateMachineEventHandler_ = nullptr;
842 std::shared_ptr<CellularDataStateMachine> stateMachine = nullptr;
843 con.AddConnectionStateMachine(stateMachine);
844 con.RemoveConnectionStateMachine(stateMachine);
845 con.AddActiveConnectionByCid(stateMachine);
846 con.GetActiveConnectionByCid(1);
847 con.GetAllConnectionMachine();
848 con.StartStallDetectionTimer();
849 con.StopStallDetectionTimer();
850 con.RegisterRadioObserver();
851 con.UnRegisterRadioObserver();
852 con.UpdateBandWidthsUseLte();
853 con.GetActiveConnection();
854 con.IsBandwidthSourceModem();
855 ASSERT_EQ(-1, con.GetDataRecoveryState());
856 con.IsNeedDoRecovery(true);
857 ASSERT_TRUE(con.GetActiveConnectionByCid(0) == nullptr);
858 ASSERT_TRUE(con.isNoActiveConnection());
859 auto event = AppExecFwk::InnerEvent::Get(0);
860 event = nullptr;
861 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
862 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
863 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED);
864 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
865 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_CALL_LIST_CHANGED);
866 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
867 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_LINK_CAPABILITY_CHANGED);
868 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
869 event = AppExecFwk::InnerEvent::Get(0);
870 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
871 ccmDefaultState.RadioDataCallListChanged(event);
872 ccmDefaultState.UpdateNetworkInfo(event);
873 ccmDefaultState.RadioLinkCapabilityChanged(event);
874 con.GetDataFlowType();
875 con.GetDefaultBandWidthsConfig();
876 con.GetDefaultTcpBufferConfig();
877 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
878 con.UpdateCallState(0);
879 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
880 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
881 }
882
883 /**
884 * @tc.number CellularDataConnectionManager_002
885 * @tc.name test error branch
886 * @tc.desc Function test
887 */
888 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_002, Function | MediumTest | Level3)
889 {
890 DataConnectionManager con { 0 };
891 con.Init();
892 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
893 std::shared_ptr<CellularDataStateMachine> stateMachine = machine->CreateCellularDataConnect(0);
894 con.AddConnectionStateMachine(stateMachine);
895 con.RemoveConnectionStateMachine(stateMachine);
896 con.AddActiveConnectionByCid(stateMachine);
897 con.GetActiveConnectionByCid(1);
898 con.GetAllConnectionMachine();
899 con.StartStallDetectionTimer();
900 con.StopStallDetectionTimer();
901 con.RegisterRadioObserver();
902 con.UnRegisterRadioObserver();
903 con.uplinkUseLte_ = true;
904 con.UpdateBandWidthsUseLte();
905 con.GetActiveConnection();
906 con.IsBandwidthSourceModem();
907 ASSERT_NE(-1, con.GetDataRecoveryState());
908 con.IsNeedDoRecovery(true);
909 con.GetActiveConnectionByCid(0);
910 con.isNoActiveConnection();
911 auto event = AppExecFwk::InnerEvent::Get(0);
912 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
913 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
914 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED);
915 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
916 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_CALL_LIST_CHANGED);
917 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
918 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_LINK_CAPABILITY_CHANGED);
919 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
920 event = AppExecFwk::InnerEvent::Get(0);
921 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
922 ccmDefaultState.RadioDataCallListChanged(event);
923 ccmDefaultState.UpdateNetworkInfo(event);
924 ccmDefaultState.RadioLinkCapabilityChanged(event);
925 con.GetDataFlowType();
926 con.GetDefaultBandWidthsConfig();
927 con.GetDefaultTcpBufferConfig();
928 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
929 con.UpdateCallState(0);
930 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
931 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
932 }
933
934 /**
935 * @tc.number DataConnectionMonitor_001
936 * @tc.name test error branch
937 * @tc.desc Function test
938 */
939 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_001, Function | MediumTest | Level3)
940 {
941 DataConnectionManager con { 0 };
942 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
943 con.connectionMonitor_->trafficManager_ = nullptr;
944 con.connectionMonitor_->stallDetectionTrafficManager_ = nullptr;
945 con.connectionMonitor_->UpdateFlowInfo();
946 con.connectionMonitor_->UpdateCallState(0);
947 con.connectionMonitor_->OnStallDetectionTimer();
948 con.connectionMonitor_->StopStallDetectionTimer();
949 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
950 con.connectionMonitor_->HandleRecovery();
951 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
952 con.connectionMonitor_->HandleRecovery();
953 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
954 con.connectionMonitor_->HandleRecovery();
955 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
956 con.connectionMonitor_->HandleRecovery();
957 con.connectionMonitor_->EndNetStatistics();
958 con.connectionMonitor_->UpdateNetTrafficState();
959 auto event = AppExecFwk::InnerEvent::Get(0);
960 con.connectionMonitor_->SetPreferredNetworkPara(event);
961 con.connectionMonitor_->UpdateDataFlowType();
962 con.connectionMonitor_->ProcessEvent(event);
963 event = nullptr;
964 con.connectionMonitor_->ProcessEvent(event);
965 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
966 }
967
968 /**
969 * @tc.number DataConnectionMonitor_002
970 * @tc.name test error branch
971 * @tc.desc Function test
972 */
973 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_002, Function | MediumTest | Level3)
974 {
975 DataConnectionManager con { 0 };
976 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
977 con.connectionMonitor_->UpdateFlowInfo();
978 con.connectionMonitor_->UpdateCallState(0);
979 con.connectionMonitor_->OnStallDetectionTimer();
980 con.connectionMonitor_->StopStallDetectionTimer();
981 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
982 con.connectionMonitor_->HandleRecovery();
983 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
984 con.connectionMonitor_->HandleRecovery();
985 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
986 con.connectionMonitor_->HandleRecovery();
987 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
988 con.connectionMonitor_->HandleRecovery();
989 con.connectionMonitor_->EndNetStatistics();
990 con.connectionMonitor_->UpdateNetTrafficState();
991 auto event = AppExecFwk::InnerEvent::Get(0);
992 con.connectionMonitor_->SetPreferredNetworkPara(event);
993 con.connectionMonitor_->UpdateDataFlowType();
994 con.connectionMonitor_->ProcessEvent(event);
995 event = nullptr;
996 con.connectionMonitor_->ProcessEvent(event);
997 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
998 }
999
1000 /**
1001 * @tc.number CellularDataUtils_001
1002 * @tc.name test error branch
1003 * @tc.desc Function test
1004 */
1005 HWTEST_F(BranchTest, Telephony_CellularDataUtils_001, Function | MediumTest | Level3)
1006 {
1007 ASSERT_EQ("unknown",
1008 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_UNKNOWN)));
1009 ASSERT_EQ(
1010 "EDGE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_GSM)));
1011 ASSERT_EQ("1xRTT",
1012 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_1XRTT)));
1013 ASSERT_EQ("UMTS",
1014 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_WCDMA)));
1015 ASSERT_EQ(
1016 "HSPA", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPA)));
1017 ASSERT_EQ("HSPAP",
1018 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPAP)));
1019 ASSERT_EQ("TD-SCDMA",
1020 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_TD_SCDMA)));
1021 ASSERT_EQ(
1022 "EVDO", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EVDO)));
1023 ASSERT_EQ("eHRPD",
1024 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EHRPD)));
1025 ASSERT_EQ(
1026 "LTE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE)));
1027 ASSERT_EQ("LTE_CA",
1028 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE_CA)));
1029 ASSERT_EQ("IWAN",
1030 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_IWLAN)));
1031 ASSERT_EQ(
1032 "NR", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_NR)));
1033 ASSERT_EQ(
1034 "unknown", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(INVALID_SLOTID)));
1035 ASSERT_TRUE(CellularDataUtils::Split("", "").empty());
1036 EXPECT_GE(DelayedSingleton<CellularDataClient>::GetInstance()->GetCellularDataFlowType(), 0);
1037 auto recipient =
1038 std::make_shared<CellularDataClient::CellularDataDeathRecipient>(CellularDataClient::GetInstance());
1039 recipient->OnRemoteDied(nullptr);
1040 EXPECT_GE(DelayedSingleton<CellularDataClient>::GetInstance()->GetCellularDataFlowType(), 0);
1041 }
1042
1043 /**
1044 * @tc.number Telephony_ApnHolder_001
1045 * @tc.name test error branch
1046 * @tc.desc Function test
1047 */
1048 HWTEST_F(BranchTest, Telephony_ApnHolder_001, Function | MediumTest | Level3)
1049 {
1050 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1051 apnHolder->ReleaseAllCellularData();
1052 apnHolder->GetNextRetryApn();
1053 std::vector<sptr<ApnItem>> matchedApns;
1054 apnHolder->SetAllMatchedApns(matchedApns);
1055 apnHolder->GetRetryDelay();
1056 sptr<ApnItem> apnItem;
1057 apnHolder->SetCurrentApn(apnItem);
1058 apnHolder->GetCurrentApn();
1059 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1060 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
1061 apnHolder->GetApnState();
1062 apnHolder->IsDataCallEnabled();
1063 apnHolder->GetApnType();
1064 apnHolder->ReleaseDataConnection();
1065 apnHolder->cellularDataStateMachine_ = nullptr;
1066 apnHolder->ReleaseDataConnection();
1067 apnHolder->SetCellularDataStateMachine(apnHolder->cellularDataStateMachine_);
1068 apnHolder->InitialApnRetryCount();
1069 apnHolder->GetCellularDataStateMachine();
1070 apnHolder->GetCapability();
1071 apnHolder->GetPriority();
1072 apnHolder->InitialApnRetryCount();
1073 NetRequest request;
1074 request.ident = "test";
1075 request.capability = -1;
1076 apnHolder->RequestCellularData(request);
1077 apnHolder->ReleaseCellularData(request);
1078 apnHolder->RequestCellularData(request);
1079 apnHolder->ReleaseCellularData(request);
1080 ASSERT_FALSE(apnHolder->IsEmergencyType());
1081 ASSERT_FALSE(apnHolder->IsMmsType());
1082 EXPECT_GE(apnHolder->GetProfileId(DATA_CONTEXT_ROLE_DEFAULT), DATA_PROFILE_DEFAULT);
1083 EXPECT_GE(apnHolder->GetProfileId("test"), DATA_PROFILE_DEFAULT);
1084 }
1085
1086 /**
1087 * @tc.number Telephony_ApnHolder_002
1088 * @tc.name test error branch
1089 * @tc.desc Function test
1090 */
1091 HWTEST_F(BranchTest, Telephony_ApnHolder_002, Function | MediumTest | Level3)
1092 {
1093 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1094 std::vector<sptr<ApnItem>> newMatchedApns;
1095 std::vector<sptr<ApnItem>> oldMatchedApns;
1096 apnHolder->SetAllMatchedApns(oldMatchedApns);
1097 ASSERT_FALSE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1098 sptr<ApnItem> apnItemFirst = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1099 newMatchedApns.push_back(apnItemFirst);
1100 oldMatchedApns.push_back(apnItemFirst);
1101 apnHolder->SetAllMatchedApns(oldMatchedApns);
1102 ASSERT_TRUE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1103 sptr<ApnItem> apnItemSecond = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1104 newMatchedApns.push_back(apnItemSecond);
1105 ASSERT_FALSE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1106 }
1107
1108 /**
1109 * @tc.number Telephony_ApnHolder_003
1110 * @tc.name test error branch
1111 * @tc.desc Function test
1112 */
1113 HWTEST_F(BranchTest, Telephony_ApnHolder_003, Function | MediumTest | Level3)
1114 {
1115 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1116 sptr<ApnItem> newApnItem;
1117 sptr<ApnItem> oldApnItem;
1118 ASSERT_FALSE(apnHolder->IsSameApnItem(newApnItem, oldApnItem, true));
1119 newApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1120 oldApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1121 ASSERT_TRUE(apnHolder->IsSameApnItem(newApnItem, oldApnItem, true));
1122 oldApnItem->CanDealWithType(DATA_CONTEXT_ROLE_DEFAULT);
1123 oldApnItem->GetApnTypes();
1124 PdpProfile apnBean;
1125 oldApnItem->MakeApn(apnBean);
1126 oldApnItem->MarkBadApn(false);
1127 ASSERT_FALSE(oldApnItem->IsBadApn());
1128 }
1129
1130 /**
1131 * @tc.number NetworkSearchCallback_Test_01
1132 * @tc.name TestDump
1133 * @tc.desc Function test
1134 */
1135 HWTEST_F(BranchTest, NetworkSearchCallback_Test_01, Function | MediumTest | Level3)
1136 {
1137 auto networkSearchCallback = std::make_shared<NetworkSearchCallback>();
1138 networkSearchCallback->ClearCellularDataConnections(0);
1139 networkSearchCallback->ClearCellularDataConnections(-1);
1140 networkSearchCallback->HasInternetCapability(0, 0);
1141 ASSERT_FALSE(networkSearchCallback->HasInternetCapability(-1, -1));
1142 }
1143
1144 /**
1145 * @tc.number StateNotification_Test_01
1146 * @tc.name TestDump
1147 * @tc.desc Function test
1148 */
1149 HWTEST_F(BranchTest, StateNotification_Test_01, Function | MediumTest | Level3)
1150 {
1151 StateNotification::GetInstance().UpdateCellularDataConnectState(0, PROFILE_STATE_DISCONNECTING, 0);
1152 StateNotification::GetInstance().OnUpDataFlowtype(0, CellDataFlowType::DATA_FLOW_TYPE_NONE);
1153 StateNotification::GetInstance().OnUpDataFlowtype(1, CellDataFlowType::DATA_FLOW_TYPE_UP_DOWN);
1154 std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr;
1155 auto cellularDataRdbObserver = std::make_shared<CellularDataRdbObserver>(cellularDataHandler);
1156 cellularDataRdbObserver->OnChange();
1157 ASSERT_TRUE(cellularDataHandler == nullptr);
1158 }
1159
1160 /**
1161 * @tc.number Active_Test_01
1162 * @tc.name TestDump
1163 * @tc.desc Function test
1164 */
1165 HWTEST_F(BranchTest, Active_Test_01, Function | MediumTest | Level3)
1166 {
1167 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1168 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1169 cellularMachine->Init();
1170 auto active = static_cast<Active *>(cellularMachine->activeState_.GetRefPtr());
1171 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1172 active->stateMachine_ = stateMachine1;
1173 active->StateBegin();
1174 active->StateEnd();
1175 auto event = AppExecFwk::InnerEvent::Get(0);
1176 event = nullptr;
1177 active->RefreshTcpBufferSizes();
1178 active->RefreshConnectionBandwidths();
1179 active->ProcessConnectDone(event);
1180 ASSERT_FALSE(active->StateProcess(event));
1181 ASSERT_FALSE(active->ProcessDisconnectDone(event));
1182 ASSERT_FALSE(active->ProcessDisconnectAllDone(event));
1183 ASSERT_FALSE(active->ProcessLostConnection(event));
1184 ASSERT_FALSE(active->ProcessRilAdapterHostDied(event));
1185 ASSERT_FALSE(active->ProcessLinkCapabilityChanged(event));
1186 ASSERT_FALSE(active->ProcessNrStateChanged(event));
1187 ASSERT_FALSE(active->ProcessNrFrequencyChanged(event));
1188 ASSERT_FALSE(active->ProcessDataConnectionComplete(event));
1189 ASSERT_FALSE(active->ProcessDataConnectionVoiceCallStartedOrEnded(event));
1190 ASSERT_FALSE(active->ProcessDataConnectionRoamOn(event));
1191 ASSERT_FALSE(active->ProcessDataConnectionRoamOff(event));
1192 }
1193
1194 /**
1195 * @tc.number Activating_Test_01
1196 * @tc.name TestDump
1197 * @tc.desc Function test
1198 */
1199 HWTEST_F(BranchTest, Activating_Test_02, Function | MediumTest | Level3)
1200 {
1201 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1202 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1203 cellularMachine->Init();
1204 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
1205 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1206 activating->stateMachine_ = stateMachine1;
1207 activating->StateBegin();
1208 activating->StateEnd();
1209 auto event = AppExecFwk::InnerEvent::Get(0);
1210 event = nullptr;
1211 activating->ProcessConnectTimeout(event);
1212 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_RETRY);
1213 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_UNKNOWN);
1214 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_SHORTAGE_RESOURCES);
1215 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_ACTIVATION_REJECTED_UNSPECIFIED);
1216 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_SERVICE_OPTION_TEMPORARILY_OUT_OF_ORDER);
1217 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_APN_NOT_SUPPORTED_IN_CURRENT_RAT_PLMN);
1218 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_APN_RESTRICTION_VALUE_INCOMPATIBLE);
1219 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_MULT_ACCESSES_PDN_NOT_ALLOWED);
1220 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_OPERATOR_DETERMINED_BARRING);
1221 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_MISSING_OR_UNKNOWN_APN);
1222 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_UNKNOWN_PDP_ADDR_OR_TYPE);
1223 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_USER_VERIFICATION);
1224 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_ACTIVATION_REJECTED_GGSN);
1225 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_SERVICE_OPTION_NOT_SUPPORTED);
1226 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_REQUESTED_SERVICE_OPTION_NOT_SUBSCRIBED);
1227 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_NSAPI_ALREADY_USED);
1228 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_IPV4_ONLY_ALLOWED);
1229 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_IPV6_ONLY_ALLOWED);
1230 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_IPV4V6_ONLY_ALLOWED);
1231 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_NON_IP_ONLY_ALLOWED);
1232 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_MAX_NUM_OF_PDP_CONTEXTS);
1233 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_PROTOCOL_ERRORS);
1234 activating->DataCallPdpError(-1);
1235 ASSERT_FALSE(activating->RilActivatePdpContextDone(event));
1236 ASSERT_FALSE(activating->RilErrorResponse(event));
1237 ASSERT_FALSE(activating->StateProcess(event));
1238 }
1239
1240 /**
1241 * @tc.number Inactive_Test_01
1242 * @tc.name TestDump
1243 * @tc.desc Function test
1244 */
1245 HWTEST_F(BranchTest, Inactive_Test_01, Function | MediumTest | Level3)
1246 {
1247 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1248 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1249 cellularMachine->Init();
1250 auto inactive = static_cast<Inactive *>(cellularMachine->inActiveState_.GetRefPtr());
1251 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1252 inactive->SetStateMachine(stateMachine1);
1253 auto event = AppExecFwk::InnerEvent::Get(0);
1254 event = nullptr;
1255 inactive->StateBegin();
1256 inactive->StateEnd();
1257 inactive->SetDeActiveApnTypeId(0);
1258 inactive->SetReason(DisConnectionReason::REASON_NORMAL);
1259 ASSERT_FALSE(inactive->StateProcess(event));
1260 }
1261
1262 /**
1263 * @tc.number Disconnecting_Test_01
1264 * @tc.name TestDump
1265 * @tc.desc Function test
1266 */
1267 HWTEST_F(BranchTest, Disconnecting_Test_01, Function | MediumTest | Level3)
1268 {
1269 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1270 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1271 cellularMachine->Init();
1272 auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
1273 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1274 disconnecting->stateMachine_ = stateMachine1;
1275 auto event = AppExecFwk::InnerEvent::Get(0);
1276 event = nullptr;
1277 disconnecting->StateBegin();
1278 disconnecting->StateEnd();
1279 disconnecting->ProcessDisconnectTimeout(event);
1280 disconnecting->ProcessRilAdapterHostDied(event);
1281 ASSERT_FALSE(disconnecting->StateProcess(event));
1282 }
1283
1284 /**
1285 * @tc.number Default_Test_01
1286 * @tc.name TestDump
1287 * @tc.desc Function test
1288 */
1289 HWTEST_F(BranchTest, Default_Test_01, Function | MediumTest | Level3)
1290 {
1291 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1292 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1293 cellularMachine->Init();
1294 auto mDefault = static_cast<Default *>(cellularMachine->defaultState_.GetRefPtr());
1295 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1296 mDefault->stateMachine_ = stateMachine1;
1297 auto event = AppExecFwk::InnerEvent::Get(0);
1298 event = nullptr;
1299 mDefault->StateBegin();
1300 mDefault->StateEnd();
1301 ASSERT_FALSE(mDefault->StateProcess(event));
1302 ASSERT_FALSE(mDefault->ProcessConnectDone(event));
1303 ASSERT_FALSE(mDefault->ProcessDisconnectDone(event));
1304 ASSERT_FALSE(mDefault->ProcessDisconnectAllDone(event));
1305 ASSERT_FALSE(mDefault->ProcessDataConnectionDrsOrRatChanged(event));
1306 ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOn(event));
1307 ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOff(event));
1308 ASSERT_FALSE(mDefault->ProcessDataCallListChanged(event));
1309 }
1310
1311 /**
1312 * @tc.number ApnManager_Test_01
1313 * @tc.name TestDump
1314 * @tc.desc Function test
1315 */
1316 HWTEST_F(BranchTest, ApnManager_Test_01, Function | MediumTest | Level3)
1317 {
1318 auto apnManager = std::make_shared<ApnManager>();
1319 apnManager->CreateAllApnItem();
1320 EXPECT_GE(apnManager->CreateAllApnItemByDatabase(0), 0);
1321 EXPECT_EQ(apnManager->CreateAllApnItemByDatabase(0), 0);
1322 apnManager->ResetApns(0);
1323 std::string operatorNumeric = "46011";
1324 apnManager->GetCTOperator(0, operatorNumeric);
1325 EXPECT_EQ(operatorNumeric, "46011");
1326 apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
1327 apnManager->FindApnNameByApnId(1);
1328 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1329 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1330 cellularMachine->Init();
1331 ASSERT_TRUE(apnManager->IsDataConnectionNotUsed(cellularMachine));
1332 auto helper = CellularDataRdbHelper::GetInstance();
1333 helper->ResetApns(0);
1334 std::shared_ptr<DataShare::DataShareResultSet> result = nullptr;
1335 std::vector<PdpProfile> apnVec;
1336 helper->ReadMvnoApnResult(result, "", apnVec);
1337 PdpProfile apnBean;
1338 ASSERT_FALSE(helper->IsMvnoDataMatched("", apnBean));
1339 apnBean.mvnoType = MvnoType::ICCID;
1340 apnBean.mvnoMatchData = "test";
1341 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1342 apnBean.mvnoType = MvnoType::SPN;
1343 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1344 apnBean.mvnoType = MvnoType::GID1;
1345 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1346 apnBean.mvnoType = MvnoType::IMSI;
1347 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1348 apnBean.mvnoType = "error";
1349 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1350 helper->QueryPreferApn(0, apnVec);
1351 ASSERT_FALSE(helper->QueryPreferApn(-1, apnVec));
1352 }
1353
1354 /**
1355 * @tc.number IsMvnoDataMatched_Test_01
1356 * @tc.name Test IsMvnoDataMatched
1357 * @tc.desc Function test
1358 */
1359 HWTEST_F(BranchTest, IsMvnoDataMatched_Test_01, Function | MediumTest | Level3)
1360 {
1361 auto helper = CellularDataRdbHelper::GetInstance();
1362 PdpProfile apnBean;
1363 ASSERT_EQ(apnBean.mvnoMatchData, "");
1364 ASSERT_EQ(apnBean.mvnoType, "");
1365 ASSERT_FALSE(helper->IsMvnoDataMatched("", apnBean));
1366
1367 apnBean.mvnoType = MvnoType::ICCID;
1368 apnBean.mvnoMatchData = "";
1369 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1370
1371 apnBean.mvnoType = MvnoType::SPN;
1372 apnBean.mvnoMatchData = "\\";
1373 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1374
1375 apnBean.mvnoType = MvnoType::IMSI;
1376 apnBean.mvnoMatchData = "";
1377 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1378
1379 apnBean.mvnoType = MvnoType::GID1;
1380 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1381 }
1382
1383 /**
1384 * @tc.number IdleState_Test_01
1385 * @tc.name test error branch
1386 * @tc.desc Function test
1387 */
1388 HWTEST_F(BranchTest, Idle_Test_01, Function | MediumTest | Level3)
1389 {
1390 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1391 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1392 incallStateMachineTest->CreateIncallDataStateMachine(0);
1393 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1394 incallStateMachine->GetCurrentState();
1395 incallStateMachine->GetSlotId();
1396 incallStateMachine->GetCallState();
1397 incallStateMachine->HasAnyConnectedState();
1398 incallStateMachine->UpdateCallState(TelCallStatus::CALL_STATUS_ALERTING);
1399 incallStateMachine->IsIncallDataSwitchOn();
1400 incallStateMachine->IsSecondaryCanActiveData();
1401 incallStateMachine->CanActiveDataByRadioTech();
1402 auto idleState = static_cast<IdleState *>(incallStateMachine->idleState_.GetRefPtr());
1403 auto event = AppExecFwk::InnerEvent::Get(0);
1404 event = nullptr;
1405 idleState->StateBegin();
1406 ASSERT_FALSE(idleState->StateProcess(event));
1407 ASSERT_TRUE(idleState->ProcessCallStarted(event));
1408 ASSERT_TRUE(idleState->ProcessCallEnded(event));
1409 ASSERT_TRUE(idleState->ProcessSettingsOn(event));
1410 ASSERT_TRUE(idleState->ProcessDsdsChanged(event));
1411 idleState->StateEnd();
1412 }
1413
1414 /**
1415 * @tc.number ActivatingSecondaryState_Test_01
1416 * @tc.name test error branch
1417 * @tc.desc Function test
1418 */
1419 HWTEST_F(BranchTest, ActivatingSecondaryState_Test_01, Function | MediumTest | Level3)
1420 {
1421 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1422 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1423 incallStateMachineTest->CreateIncallDataStateMachine(0);
1424 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1425 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1426 auto activatingSecondaryState =
1427 static_cast<ActivatingSecondaryState *>(incallStateMachine->activatingSecondaryState_.GetRefPtr());
1428 auto secondaryActiveState =
1429 static_cast<SecondaryActiveState *>(incallStateMachine->secondaryActiveState_.GetRefPtr());
1430 auto event = AppExecFwk::InnerEvent::Get(0);
1431 event = nullptr;
1432 secondaryActiveState->StateBegin();
1433 activatingSecondaryState->StateBegin();
1434 ASSERT_FALSE(activatingSecondaryState->StateProcess(event));
1435 ASSERT_FALSE(secondaryActiveState->StateProcess(event));
1436 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOn(event));
1437 ASSERT_TRUE(secondaryActiveState->ProcessCallEnded(event));
1438 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOff(event));
1439 ASSERT_TRUE(secondaryActiveState->ProcessDsdsChanged(event));
1440 activatingSecondaryState->StateEnd();
1441 secondaryActiveState->StateEnd();
1442 }
1443
1444 /**
1445 * @tc.number ActivatedSecondaryState_Test_01
1446 * @tc.name test error branch
1447 * @tc.desc Function test
1448 */
1449 HWTEST_F(BranchTest, ActivatedSecondaryState_Test_01, Function | MediumTest | Level3)
1450 {
1451 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1452 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1453 incallStateMachineTest->CreateIncallDataStateMachine(0);
1454 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1455 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1456 incallStateMachine->TransitionTo(incallStateMachine->activatedSecondaryState_);
1457 auto activatedSecondaryState =
1458 static_cast<ActivatedSecondaryState *>(incallStateMachine->activatedSecondaryState_.GetRefPtr());
1459 auto secondaryActiveState =
1460 static_cast<SecondaryActiveState *>(incallStateMachine->secondaryActiveState_.GetRefPtr());
1461 auto event = AppExecFwk::InnerEvent::Get(0);
1462 event = nullptr;
1463 secondaryActiveState->StateBegin();
1464 activatedSecondaryState->StateBegin();
1465 ASSERT_FALSE(activatedSecondaryState->StateProcess(event));
1466 ASSERT_FALSE(secondaryActiveState->StateProcess(event));
1467 ASSERT_TRUE(secondaryActiveState->ProcessCallEnded(event));
1468 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOff(event));
1469 activatedSecondaryState->StateEnd();
1470 secondaryActiveState->StateEnd();
1471 }
1472
1473 /**
1474 * @tc.number DeactivatingSecondaryState_Test_01
1475 * @tc.name test error branch
1476 * @tc.desc Function test
1477 */
1478 HWTEST_F(BranchTest, DeactivatingSecondaryState_Test_01, Function | MediumTest | Level3)
1479 {
1480 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1481 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1482 incallStateMachineTest->CreateIncallDataStateMachine(0);
1483 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1484 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1485 incallStateMachine->TransitionTo(incallStateMachine->activatedSecondaryState_);
1486 incallStateMachine->TransitionTo(incallStateMachine->deactivatingSecondaryState_);
1487 auto deactivatingSecondaryState =
1488 static_cast<DeactivatingSecondaryState *>(incallStateMachine->deactivatingSecondaryState_.GetRefPtr());
1489 auto event = AppExecFwk::InnerEvent::Get(0);
1490 event = nullptr;
1491 deactivatingSecondaryState->StateBegin();
1492 ASSERT_FALSE(deactivatingSecondaryState->StateProcess(event));
1493 deactivatingSecondaryState->StateEnd();
1494 }
1495
1496 /**
1497 * @tc.number GetIpType_Test_01
1498 * @tc.name TestDump
1499 * @tc.desc Function test
1500 */
1501 HWTEST_F(BranchTest, GetIpType_Test_01, Function | MediumTest | Level3)
1502 {
1503 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1504 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1505 cellularMachine->Init();
1506 std::string result = "";
1507 std::string address = "";
1508 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1509 result = cellularMachine->GetIpType(ipInfoArray);
1510 ASSERT_TRUE(result == "");
1511 }
1512
1513 /**
1514 * @tc.number DataSwitchSettings_Test_01
1515 * @tc.name test error branch
1516 * @tc.desc Function test
1517 */
1518 HWTEST_F(BranchTest, DataSwitchSettings_Test_01, Function | MediumTest | Level3)
1519 {
1520 std::unique_ptr<DataSwitchSettings> dataSwitchSettings = std::make_unique<DataSwitchSettings>(0);
1521 dataSwitchSettings->LoadSwitchValue();
1522 bool status = true;
1523 dataSwitchSettings->QueryUserDataStatus(status);
1524 dataSwitchSettings->QueryUserDataRoamingStatus(status);
1525 dataSwitchSettings->QueryIntelligenceSwitchStatus(status);
1526 dataSwitchSettings->SetPolicyDataOn(true);
1527 ASSERT_TRUE(dataSwitchSettings->IsPolicyDataOn());
1528 dataSwitchSettings->IsAllowActiveData();
1529 dataSwitchSettings->SetUserDataOn(true);
1530 dataSwitchSettings->IsUserDataOn();
1531 dataSwitchSettings->SetCarrierDataOn(true);
1532 ASSERT_TRUE(dataSwitchSettings->IsCarrierDataOn());
1533 dataSwitchSettings->SetUserDataRoamingOn(true);
1534 dataSwitchSettings->IsUserDataRoamingOn();
1535 dataSwitchSettings->SetInternalDataOn(true);
1536 ASSERT_TRUE(dataSwitchSettings->IsInternalDataOn());
1537 dataSwitchSettings->SetIntelliSwitchOn(true);
1538 dataSwitchSettings->UpdateUserDataRoamingOn(false);
1539 ASSERT_FALSE(dataSwitchSettings->IsUserDataRoamingOn());
1540 }
1541
1542 /**
1543 * @tc.number CellularDataStateMachine_Test_01
1544 * @tc.name test error branch
1545 * @tc.desc Function test
1546 */
1547 HWTEST_F(BranchTest, CellularDataStateMachine_Test_01, Function | MediumTest | Level3)
1548 {
1549 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1550 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1551 cellularMachine->IsInactiveState();
1552 uint64_t capability = 1;
1553 cellularMachine->SetCapability(capability);
1554 cellularMachine->GetCapability();
1555 const int32_t cid = 1;
1556 cellularMachine->SetCid(cid);
1557 cellularMachine->GetSlotId();
1558 cellularMachine->GetApnItem();
1559 cellularMachine->GetCurrentState();
1560 const uint32_t upBandwidth = 0;
1561 const uint32_t downBandwidth = 0;
1562 cellularMachine->SetConnectionBandwidth(upBandwidth, downBandwidth);
1563 const std::string tcpBuffer = "";
1564 cellularMachine->SetConnectionTcpBuffer(tcpBuffer);
1565 std::string proxyIpAddress = "1234:567";
1566 std::string host = "";
1567 uint16_t port = 0;
1568 cellularMachine->SplitProxyIpAddress(proxyIpAddress, host, port);
1569 EXPECT_EQ(host, "1234");
1570 EXPECT_EQ(port, 567);
1571 EXPECT_TRUE(cellularMachine != nullptr);
1572 CellularDataDumpHelper dumpHelper;
1573 std::string result = "";
1574 dumpHelper.ShowHelp(result);
1575 EXPECT_GE(result.size(), 0);
1576 }
1577
1578 /**
1579 * @tc.number CellularDataUtils_Test_01
1580 * @tc.name test error branch
1581 * @tc.desc Function test
1582 */
1583 HWTEST_F(BranchTest, CellularDataUtils_Test_01, Function | MediumTest | Level3)
1584 {
1585 CellularDataUtils::ParseNormalIpAddr(ADDRESS);
1586 CellularDataUtils::ParseRoute(ADDRESS);
1587 CellularDataUtils::GetPrefixLen(ADDRESS, FLAG);
1588 auto cellularDataHiSysEvent = DelayedSingleton<CellularDataHiSysEvent>::GetInstance();
1589 cellularDataHiSysEvent->WriteRoamingConnectStateBehaviorEvent(1);
1590 cellularDataHiSysEvent->SetCellularDataActivateStartTime();
1591 cellularDataHiSysEvent->JudgingDataActivateTimeOut(0, 1);
1592 std::shared_ptr<DataConnectionMonitor> dataConnectionMonitor = std::make_shared<DataConnectionMonitor>(0);
1593 dataConnectionMonitor->HandleRecovery();
1594 dataConnectionMonitor->GetPdpContextList();
1595 dataConnectionMonitor->SetRadioState(0, RadioEvent::RADIO_ON);
1596 dataConnectionMonitor->GetPreferredNetworkPara();
1597 dataConnectionMonitor->GetDataFlowType();
1598 dataConnectionMonitor->IsNeedDoRecovery(true);
1599 dataConnectionMonitor->IsNeedDoRecovery(false);
1600 auto cellularDataService = DelayedSingleton<CellularDataService>::GetInstance();
1601 MessageParcel data;
1602 MessageParcel reply;
1603 EXPECT_GE(cellularDataService->OnIsCellularDataEnabled(data, reply), 0);
1604 EXPECT_GE(cellularDataService->OnEnableCellularData(data, reply), 0);
1605 EXPECT_GE(cellularDataService->OnGetCellularDataState(data, reply), 0);
1606 EXPECT_GE(cellularDataService->OnIsCellularDataRoamingEnabled(data, reply), 0);
1607 EXPECT_GE(cellularDataService->OnEnableCellularDataRoaming(data, reply), 0);
1608 EXPECT_GE(cellularDataService->OnHandleApnChanged(data, reply), 0);
1609 cellularDataService->OnGetDefaultCellularDataSlotId(data, reply);
1610 EXPECT_GE(cellularDataService->OnGetDefaultCellularDataSimId(data, reply), 0);
1611 EXPECT_GE(cellularDataService->OnSetDefaultCellularDataSlotId(data, reply), 0);
1612 EXPECT_GE(cellularDataService->OnGetCellularDataFlowType(data, reply), 0);
1613 EXPECT_GE(cellularDataService->OnHasInternetCapability(data, reply), 0);
1614 EXPECT_GE(cellularDataService->OnClearCellularDataConnections(data, reply), 0);
1615 EXPECT_GE(cellularDataService->OnRegisterSimAccountCallback(data, reply), 0);
1616 EXPECT_GE(cellularDataService->OnUnregisterSimAccountCallback(data, reply), 0);
1617 EXPECT_GE(cellularDataService->OnEnableIntelligenceSwitch(data, reply), 0);
1618 EXPECT_GE(cellularDataService->OnGetDataConnApnAttr(data, reply), 0);
1619 EXPECT_GE(cellularDataService->OnGetDataConnIpType(data, reply), 0);
1620 EXPECT_GE(cellularDataService->OnGetApnState(data, reply), 0);
1621 EXPECT_GE(cellularDataService->OnGetRecoveryState(data, reply), 0);
1622 EXPECT_GE(cellularDataService->OnIsNeedDoRecovery(data, reply), 0);
1623 EXPECT_GE(cellularDataService->OnIsNeedDoRecovery(data, reply), 0);
1624 EXPECT_GE(cellularDataService->OnClearAllConnections(data, reply), 0);
1625 }
1626
1627 /**
1628 * @tc.number CellularDataSettingsRdbHelper_Test_01
1629 * @tc.name test error branch
1630 * @tc.desc Function test
1631 */
1632 HWTEST_F(BranchTest, CellularDataSettingsRdbHelper_Test_01, Function | MediumTest | Level3)
1633 {
1634 auto settingHelper = CellularDataSettingsRdbHelper::GetInstance();
1635 if (settingHelper == nullptr) {
1636 TELEPHONY_LOGE("settingHelper is null");
1637 return;
1638 }
1639 Uri dataEnableUri(CELLULAR_DATA_SETTING_DATA_ROAMING_URI);
1640 settingHelper->RegisterSettingsObserver(dataEnableUri, nullptr);
1641 settingHelper->UnRegisterSettingsObserver(dataEnableUri, nullptr);
1642 EXPECT_TRUE(settingHelper != nullptr);
1643 }
1644
1645 /**
1646 * @tc.number FindBestCapability_Test_01
1647 * @tc.name test branch
1648 * @tc.desc Function test
1649 */
1650 HWTEST_F(BranchTest, FindBestCapability_Test_01, Function | MediumTest | Level3)
1651 {
1652 auto apnManager = std::make_shared<ApnManager>();
1653
1654 uint64_t capabilities = 1L << NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET;
1655 auto ret = apnManager->FindBestCapability(capabilities);
1656 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
1657
1658 capabilities |= 1L << NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT;
1659 ret = apnManager->FindBestCapability(capabilities);
1660 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT);
1661
1662 capabilities |= 1L << NetManagerStandard::NetCap::NET_CAPABILITY_MMS;
1663 ret = apnManager->FindBestCapability(capabilities);
1664 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_MMS);
1665 }
1666
1667 /**
1668 * @tc.number GetOverallDefaultApnState_Test_01
1669 * @tc.name test branch
1670 * @tc.desc Function test
1671 */
1672 HWTEST_F(BranchTest, GetOverallDefaultApnState_Test_01, Function | MediumTest | Level3)
1673 {
1674 auto apnManager = std::make_shared<ApnManager>();
1675 apnManager->InitApnHolders();
1676 auto &apnHolders = apnManager->apnHolders_;
1677 for (auto &apnHolder : apnHolders) {
1678 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1679 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1680 }
1681 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1682 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1683 }
1684 }
1685 auto ret = apnManager->GetOverallDefaultApnState();
1686 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_IDLE);
1687
1688 for (auto &apnHolder : apnHolders) {
1689 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1690 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
1691 }
1692 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1693 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1694 }
1695 }
1696 ret = apnManager->GetOverallDefaultApnState();
1697 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
1698
1699 for (auto &apnHolder : apnHolders) {
1700 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1701 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1702 }
1703 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1704 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
1705 }
1706 }
1707 ret = apnManager->GetOverallDefaultApnState();
1708 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
1709 }
1710
1711 /**
1712 * @tc.number GetOverallDefaultApnState_Test_02
1713 * @tc.name test branch
1714 * @tc.desc Function test
1715 */
1716 HWTEST_F(BranchTest, GetOverallDefaultApnState_Test_02, Function | MediumTest | Level3)
1717 {
1718 auto apnManager = std::make_shared<ApnManager>();
1719 apnManager->InitApnHolders();
1720 auto &apnHolders = apnManager->apnHolders_;
1721
1722 for (auto &apnHolder : apnHolders) {
1723 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1724 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTED);
1725 }
1726 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1727 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_DISCONNECTING);
1728 }
1729 }
1730 auto ret = apnManager->GetOverallDefaultApnState();
1731 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTED);
1732
1733 for (auto &apnHolder : apnHolders) {
1734 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1735 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTED);
1736 }
1737 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1738 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
1739 }
1740 }
1741 ret = apnManager->GetOverallDefaultApnState();
1742 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTED);
1743
1744 for (auto &apnHolder : apnHolders) {
1745 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1746 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
1747 }
1748 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1749 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
1750 }
1751 }
1752 ret = apnManager->GetOverallDefaultApnState();
1753 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
1754 }
1755
1756 /**
1757 * @tc.number ParseIpAddr_001
1758 * @tc.name test branch
1759 * @tc.desc Function test
1760 */
1761 HWTEST_F(BranchTest, ParseIpAddr_001, Function | MediumTest | Level0)
1762 {
1763 std::string address = "";
1764 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1765 EXPECT_EQ(ipInfoArray.size(), 0);
1766 }
1767
1768 /**
1769 * @tc.number ParseIpAddr_002
1770 * @tc.name test branch
1771 * @tc.desc Function test
1772 */
1773 HWTEST_F(BranchTest, ParseIpAddr_002, Function | MediumTest | Level0)
1774 {
1775 std::string address = "192.000.1.1/24";
1776 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1777 EXPECT_EQ(ipInfoArray.size(), 1);
1778 }
1779
1780 /**
1781 * @tc.number ParseIpAddr_003
1782 * @tc.name test branch
1783 * @tc.desc Function test
1784 */
1785 HWTEST_F(BranchTest, ParseIpAddr_003, Function | MediumTest | Level0)
1786 {
1787 std::string address = "192.000.1.1/24 192.000.1.2/24";
1788 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1789 EXPECT_EQ(ipInfoArray.size(), 2);
1790 }
1791
1792 /**
1793 * @tc.number ParseIpAddr_004
1794 * @tc.name test branch
1795 * @tc.desc Function test
1796 */
1797 HWTEST_F(BranchTest, ParseIpAddr_004, Function | MediumTest | Level0)
1798 {
1799 std::string address = "2001:0000:0000:0000:0000:0000:0000:0000/64";
1800 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1801 EXPECT_EQ(ipInfoArray.size(), 1);
1802 }
1803
1804 /**
1805 * @tc.number ParseIpAddr_005
1806 * @tc.name test branch
1807 * @tc.desc Function test
1808 */
1809 HWTEST_F(BranchTest, ParseIpAddr_005, Function | MediumTest | Level0)
1810 {
1811 std::string address = "2001:0000:0000:0000:0000:0000:0000:0000/64 2001:0000:0000:0000:0000:0000:0000:0000/64";
1812 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1813 EXPECT_EQ(ipInfoArray.size(), 2);
1814 }
1815
1816 /**
1817 * @tc.number GetPrefixLen_001
1818 * @tc.name test branch
1819 * @tc.desc Function test
1820 */
1821 HWTEST_F(BranchTest, GetPrefixLen_001, Function | MediumTest | Level0)
1822 {
1823 std::vector<std::string> netmask;
1824 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1825 EXPECT_EQ(result, 0);
1826 }
1827
1828 /**
1829 * @tc.number GetPrefixLen_002
1830 * @tc.name test branch
1831 * @tc.desc Function test
1832 */
1833 HWTEST_F(BranchTest, GetPrefixLen_002, Function | MediumTest | Level0)
1834 {
1835 std::vector<std::string> netmask = {"255", "invalid", "255"};
1836 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1837 EXPECT_EQ(result, 8);
1838 }
1839
1840 /**
1841 * @tc.number GetPrefixLen_003
1842 * @tc.name test branch
1843 * @tc.desc Function test
1844 */
1845 HWTEST_F(BranchTest, GetPrefixLen_003, Function | MediumTest | Level0)
1846 {
1847 std::vector<std::string> netmask = {"255", "0", "255"};
1848 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1849 EXPECT_EQ(result, 8);
1850 }
1851
1852 /**
1853 * @tc.number GetPrefixLen_004
1854 * @tc.name test branch
1855 * @tc.desc Function test
1856 */
1857 HWTEST_F(BranchTest, GetPrefixLen_004, Function | MediumTest | Level0)
1858 {
1859 std::vector<std::string> netmask = {"255", "254", "255"};
1860 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1861 EXPECT_EQ(result, 15);
1862 }
1863
1864 /**
1865 * @tc.number GetPrefixLen_005
1866 * @tc.name test branch
1867 * @tc.desc Function test
1868 */
1869 HWTEST_F(BranchTest, GetPrefixLen_005, Function | MediumTest | Level0)
1870 {
1871 std::vector<std::string> netmask = {"255", "256", "255"};
1872 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1873 EXPECT_EQ(result, 8);
1874 }
1875
1876 /**
1877 * @tc.number GetPrefixLen_006
1878 * @tc.name test branch
1879 * @tc.desc Function test
1880 */
1881 HWTEST_F(BranchTest, GetPrefixLen_006, Function | MediumTest | Level0)
1882 {
1883 std::vector<std::string> netmask = {"255", "254", "255"};
1884 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1885 EXPECT_EQ(result, 15);
1886 }
1887
1888 /**
1889 * @tc.number GetPrefixLen_007
1890 * @tc.name test branch
1891 * @tc.desc Function test
1892 */
1893 HWTEST_F(BranchTest, GetPrefixLen_007, Function | MediumTest | Level0)
1894 {
1895 std::vector<std::string> netmask = {"255", "255", "255"};
1896 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1897 EXPECT_EQ(result, 24);
1898 }
1899
1900 /**
1901 * @tc.number JudgingDataActivateTimeOut_001
1902 * @tc.name test branch
1903 * @tc.desc Function test
1904 */
1905 HWTEST_F(BranchTest, JudgingDataActivateTimeOut_001, Function | MediumTest | Level0)
1906 {
1907 auto cellularDataHiSysEvent = DelayedSingleton<CellularDataHiSysEvent>::GetInstance();
1908 int32_t slotId = 1;
1909 int32_t switchState = 1;
1910 cellularDataHiSysEvent->dataActivateStartTime_ = -1000;
1911 cellularDataHiSysEvent->JudgingDataActivateTimeOut(slotId, switchState);
1912 cellularDataHiSysEvent->SetCellularDataActivateStartTime();
1913 EXPECT_NE(cellularDataHiSysEvent->dataActivateStartTime_, -1000);
1914 }
1915
1916 /**
1917 * @tc.number ReadMvnoApnResult_001
1918 * @tc.name Test the function
1919 * @tc.desc Function test
1920 */
1921 HWTEST_F(BranchTest, ReadMvnoApnResult_001, TestSize.Level3)
1922 {
1923 std::shared_ptr<DataShare::DataShareResultSet> result = nullptr;
1924 std::string mvnoDataFromSim = "mvnoDataFromSim";
1925 std::vector<PdpProfile> apnVec;
1926 CellularDataRdbHelper cellularDataRdbHelper;
1927 cellularDataRdbHelper.ReadMvnoApnResult(nullptr, mvnoDataFromSim, apnVec);
1928 ASSERT_TRUE(apnVec.empty());
1929 }
1930
1931 /**
1932 * @tc.number ReadMvnoApnResult_002
1933 * @tc.name Test the function
1934 * @tc.desc Function test
1935 */
1936 HWTEST_F(BranchTest, ReadMvnoApnResult_002, TestSize.Level3)
1937 {
1938 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
1939 std::string mvnoDataFromSim = "mvnoDataFromSim";
1940 std::vector<PdpProfile> apnVec;
1941 CellularDataRdbHelper cellularDataRdbHelper;
1942 cellularDataRdbHelper.ReadMvnoApnResult(nullptr, mvnoDataFromSim, apnVec);
1943 ASSERT_TRUE(apnVec.empty());
1944 }
1945
1946 /**
1947 * @tc.number MakePdpProfile_001
1948 * @tc.name Test the function
1949 * @tc.desc Function test
1950 */
1951 HWTEST_F(BranchTest, MakePdpProfile_001, TestSize.Level3)
1952 {
1953 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
1954 int i = 0;
1955 PdpProfile apnBean;
1956 apnBean.pdpProtocol = "";
1957 apnBean.roamPdpProtocol = "";
1958 CellularDataRdbHelper cellularDataRdbHelper;
1959 cellularDataRdbHelper.MakePdpProfile(result, i, apnBean);
1960 ASSERT_EQ("IP", apnBean.pdpProtocol);
1961 ASSERT_EQ("IP", apnBean.roamPdpProtocol);
1962 }
1963
1964 /**
1965 * @tc.number MakePdpProfile_002
1966 * @tc.name Test the function
1967 * @tc.desc Function test
1968 */
1969 HWTEST_F(BranchTest, MakePdpProfile_002, TestSize.Level3)
1970 {
1971 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
1972 int i = 0;
1973 PdpProfile apnBean;
1974 apnBean.pdpProtocol = "ABC";
1975 apnBean.roamPdpProtocol = "abc";
1976 CellularDataRdbHelper cellularDataRdbHelper;
1977 cellularDataRdbHelper.MakePdpProfile(result, i, apnBean);
1978 ASSERT_EQ("ABC", apnBean.pdpProtocol);
1979 ASSERT_EQ("abc", apnBean.roamPdpProtocol);
1980 }
1981 } // namespace Telephony
1982 } // namespace OHOS
1983