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_NE(controller.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
768 ASSERT_NE(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState());
769 ASSERT_NE(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState(""));
770 if (controller.systemAbilityListener_ != nullptr) {
771 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
772 controller.systemAbilityListener_->OnAddSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
773 controller.systemAbilityListener_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
774 controller.systemAbilityListener_->OnAddSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
775 controller.systemAbilityListener_->OnAddSystemAbility(0, "test");
776 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "test");
777 controller.systemAbilityListener_->OnRemoveSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "test");
778 controller.systemAbilityListener_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "test");
779 controller.systemAbilityListener_->OnRemoveSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "test");
780 controller.systemAbilityListener_->OnRemoveSystemAbility(0, "test");
781 }
782 bool dataRoamingEnabled = false;
783 controller.IsCellularDataRoamingEnabled(dataRoamingEnabled);
784 ASSERT_TRUE(controller.HandleApnChanged());
785 auto event = AppExecFwk::InnerEvent::Get(0);
786 controller.ProcessEvent(event);
787 event = nullptr;
788 controller.ProcessEvent(event);
789 controller.RegisterEvents();
790 ASSERT_FALSE(controller.IsRestrictedMode());
791 ASSERT_EQ(DisConnectionReason::REASON_NORMAL, controller.GetDisConnectionReason());
792 controller.HasInternetCapability(0);
793 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
794 ASSERT_TRUE(controller.ClearAllConnections(reason));
795 controller.ChangeConnectionForDsds(false);
796 ASSERT_FALSE(controller.GetCellularDataFlowType());
797 controller.UnRegisterEvents();
798 if (controller.cellularDataHandler_ != nullptr) {
799 controller.cellularDataHandler_->UnRegisterDataSettingObserver();
800 controller.cellularDataHandler_->RemoveAllEvents();
801 sleep(SLEEP_TIME_SECONDS);
802 }
803 }
804
805 /**
806 * @tc.number CellularDataController_003
807 * @tc.name test error branch
808 * @tc.desc Function test
809 */
810 HWTEST_F(BranchTest, Telephony_CellularDataController_003, Function | MediumTest | Level3)
811 {
812 CellularDataController controller { 0 };
813 controller.RegisterEvents();
814 controller.Init();
815 ApnItem::Attribute apnAttr;
816 controller.GetDataConnApnAttr(apnAttr);
817 std::string str = "";
818 ASSERT_EQ(controller.GetDataConnIpType(), str);
819 ASSERT_EQ(controller.GetDataRecoveryState(), 0);
820 controller.IsNeedDoRecovery(true);
821 controller.cellularDataHandler_ = nullptr;
822 controller.GetDataConnApnAttr(apnAttr);
823 ASSERT_EQ(controller.GetDataConnIpType(), str);
824 ASSERT_EQ(controller.GetDataRecoveryState(), 0);
825 controller.IsNeedDoRecovery(true);
826 }
827
828 /**
829 * @tc.number CellularDataConnectionManager_001
830 * @tc.name test error branch
831 * @tc.desc Function test
832 */
833 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_001, Function | MediumTest | Level3)
834 {
835 DataConnectionManager con { 0 };
836 con.Init();
837 con.connectionMonitor_ = nullptr;
838 con.ccmDefaultState_ = nullptr;
839 con.stateMachineEventHandler_ = nullptr;
840 std::shared_ptr<CellularDataStateMachine> stateMachine = nullptr;
841 con.AddConnectionStateMachine(stateMachine);
842 con.RemoveConnectionStateMachine(stateMachine);
843 con.AddActiveConnectionByCid(stateMachine);
844 con.GetActiveConnectionByCid(1);
845 con.GetAllConnectionMachine();
846 con.StartStallDetectionTimer();
847 con.StopStallDetectionTimer();
848 con.RegisterRadioObserver();
849 con.UnRegisterRadioObserver();
850 con.UpdateBandWidthsUseLte();
851 con.GetActiveConnection();
852 con.IsBandwidthSourceModem();
853 ASSERT_EQ(-1, con.GetDataRecoveryState());
854 con.IsNeedDoRecovery(true);
855 ASSERT_TRUE(con.GetActiveConnectionByCid(0) == nullptr);
856 ASSERT_TRUE(con.isNoActiveConnection());
857 auto event = AppExecFwk::InnerEvent::Get(0);
858 event = nullptr;
859 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
860 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
861 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED);
862 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
863 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_CALL_LIST_CHANGED);
864 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
865 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_LINK_CAPABILITY_CHANGED);
866 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
867 event = AppExecFwk::InnerEvent::Get(0);
868 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
869 ccmDefaultState.RadioDataCallListChanged(event);
870 ccmDefaultState.UpdateNetworkInfo(event);
871 ccmDefaultState.RadioLinkCapabilityChanged(event);
872 con.GetDataFlowType();
873 con.GetDefaultBandWidthsConfig();
874 con.GetDefaultTcpBufferConfig();
875 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
876 con.UpdateCallState(0);
877 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
878 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
879 }
880
881 /**
882 * @tc.number CellularDataConnectionManager_002
883 * @tc.name test error branch
884 * @tc.desc Function test
885 */
886 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_002, Function | MediumTest | Level3)
887 {
888 DataConnectionManager con { 0 };
889 con.Init();
890 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
891 std::shared_ptr<CellularDataStateMachine> stateMachine = machine->CreateCellularDataConnect(0);
892 con.AddConnectionStateMachine(stateMachine);
893 con.RemoveConnectionStateMachine(stateMachine);
894 con.AddActiveConnectionByCid(stateMachine);
895 con.GetActiveConnectionByCid(1);
896 con.GetAllConnectionMachine();
897 con.StartStallDetectionTimer();
898 con.StopStallDetectionTimer();
899 con.RegisterRadioObserver();
900 con.UnRegisterRadioObserver();
901 con.uplinkUseLte_ = true;
902 con.UpdateBandWidthsUseLte();
903 con.GetActiveConnection();
904 con.IsBandwidthSourceModem();
905 ASSERT_NE(-1, con.GetDataRecoveryState());
906 con.IsNeedDoRecovery(true);
907 con.GetActiveConnectionByCid(0);
908 con.isNoActiveConnection();
909 auto event = AppExecFwk::InnerEvent::Get(0);
910 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
911 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
912 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED);
913 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
914 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_CALL_LIST_CHANGED);
915 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
916 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_LINK_CAPABILITY_CHANGED);
917 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
918 event = AppExecFwk::InnerEvent::Get(0);
919 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
920 ccmDefaultState.RadioDataCallListChanged(event);
921 ccmDefaultState.UpdateNetworkInfo(event);
922 ccmDefaultState.RadioLinkCapabilityChanged(event);
923 con.GetDataFlowType();
924 con.GetDefaultBandWidthsConfig();
925 con.GetDefaultTcpBufferConfig();
926 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
927 con.UpdateCallState(0);
928 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
929 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
930 }
931
932 /**
933 * @tc.number DataConnectionMonitor_001
934 * @tc.name test error branch
935 * @tc.desc Function test
936 */
937 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_001, Function | MediumTest | Level3)
938 {
939 DataConnectionManager con { 0 };
940 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
941 con.connectionMonitor_->trafficManager_ = nullptr;
942 con.connectionMonitor_->stallDetectionTrafficManager_ = nullptr;
943 con.connectionMonitor_->UpdateFlowInfo();
944 con.connectionMonitor_->UpdateCallState(0);
945 con.connectionMonitor_->OnStallDetectionTimer();
946 con.connectionMonitor_->StopStallDetectionTimer();
947 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
948 con.connectionMonitor_->HandleRecovery();
949 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
950 con.connectionMonitor_->HandleRecovery();
951 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
952 con.connectionMonitor_->HandleRecovery();
953 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
954 con.connectionMonitor_->HandleRecovery();
955 con.connectionMonitor_->EndNetStatistics();
956 con.connectionMonitor_->UpdateNetTrafficState();
957 auto event = AppExecFwk::InnerEvent::Get(0);
958 con.connectionMonitor_->SetPreferredNetworkPara(event);
959 con.connectionMonitor_->UpdateDataFlowType();
960 con.connectionMonitor_->ProcessEvent(event);
961 event = nullptr;
962 con.connectionMonitor_->ProcessEvent(event);
963 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
964 }
965
966 /**
967 * @tc.number DataConnectionMonitor_002
968 * @tc.name test error branch
969 * @tc.desc Function test
970 */
971 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_002, Function | MediumTest | Level3)
972 {
973 DataConnectionManager con { 0 };
974 ASSERT_FALSE(con.connectionMonitor_ == nullptr);
975 con.connectionMonitor_->UpdateFlowInfo();
976 con.connectionMonitor_->UpdateCallState(0);
977 con.connectionMonitor_->OnStallDetectionTimer();
978 con.connectionMonitor_->StopStallDetectionTimer();
979 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REQUEST_CONTEXT_LIST;
980 con.connectionMonitor_->HandleRecovery();
981 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_CLEANUP_CONNECTIONS;
982 con.connectionMonitor_->HandleRecovery();
983 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_REREGISTER_NETWORK;
984 con.connectionMonitor_->HandleRecovery();
985 con.connectionMonitor_->dataRecoveryState_ = RecoveryState::STATE_RADIO_STATUS_RESTART;
986 con.connectionMonitor_->HandleRecovery();
987 con.connectionMonitor_->EndNetStatistics();
988 con.connectionMonitor_->UpdateNetTrafficState();
989 auto event = AppExecFwk::InnerEvent::Get(0);
990 con.connectionMonitor_->SetPreferredNetworkPara(event);
991 con.connectionMonitor_->UpdateDataFlowType();
992 con.connectionMonitor_->ProcessEvent(event);
993 event = nullptr;
994 con.connectionMonitor_->ProcessEvent(event);
995 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, con.connectionMonitor_->GetDataFlowType());
996 }
997
998 /**
999 * @tc.number CellularDataUtils_001
1000 * @tc.name test error branch
1001 * @tc.desc Function test
1002 */
1003 HWTEST_F(BranchTest, Telephony_CellularDataUtils_001, Function | MediumTest | Level3)
1004 {
1005 ASSERT_EQ("unknown",
1006 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_UNKNOWN)));
1007 ASSERT_EQ(
1008 "EDGE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_GSM)));
1009 ASSERT_EQ("1xRTT",
1010 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_1XRTT)));
1011 ASSERT_EQ("UMTS",
1012 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_WCDMA)));
1013 ASSERT_EQ(
1014 "HSPA", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPA)));
1015 ASSERT_EQ("HSPAP",
1016 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPAP)));
1017 ASSERT_EQ("TD-SCDMA",
1018 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_TD_SCDMA)));
1019 ASSERT_EQ(
1020 "EVDO", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EVDO)));
1021 ASSERT_EQ("eHRPD",
1022 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EHRPD)));
1023 ASSERT_EQ(
1024 "LTE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE)));
1025 ASSERT_EQ("LTE_CA",
1026 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE_CA)));
1027 ASSERT_EQ("IWAN",
1028 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_IWLAN)));
1029 ASSERT_EQ(
1030 "NR", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_NR)));
1031 ASSERT_EQ(
1032 "unknown", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(INVALID_SLOTID)));
1033 ASSERT_TRUE(CellularDataUtils::Split("", "").empty());
1034 EXPECT_GE(DelayedSingleton<CellularDataClient>::GetInstance()->GetCellularDataFlowType(), 0);
1035 auto recipient =
1036 std::make_shared<CellularDataClient::CellularDataDeathRecipient>(CellularDataClient::GetInstance());
1037 recipient->OnRemoteDied(nullptr);
1038 EXPECT_GE(DelayedSingleton<CellularDataClient>::GetInstance()->GetCellularDataFlowType(), 0);
1039 }
1040
1041 /**
1042 * @tc.number Telephony_ApnHolder_001
1043 * @tc.name test error branch
1044 * @tc.desc Function test
1045 */
1046 HWTEST_F(BranchTest, Telephony_ApnHolder_001, Function | MediumTest | Level3)
1047 {
1048 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1049 apnHolder->ReleaseAllCellularData();
1050 apnHolder->GetNextRetryApn();
1051 std::vector<sptr<ApnItem>> matchedApns;
1052 apnHolder->SetAllMatchedApns(matchedApns);
1053 apnHolder->GetRetryDelay();
1054 sptr<ApnItem> apnItem;
1055 apnHolder->SetCurrentApn(apnItem);
1056 apnHolder->GetCurrentApn();
1057 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1058 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
1059 apnHolder->GetApnState();
1060 apnHolder->IsDataCallEnabled();
1061 apnHolder->GetApnType();
1062 apnHolder->ReleaseDataConnection();
1063 apnHolder->cellularDataStateMachine_ = nullptr;
1064 apnHolder->ReleaseDataConnection();
1065 apnHolder->SetCellularDataStateMachine(apnHolder->cellularDataStateMachine_);
1066 apnHolder->InitialApnRetryCount();
1067 apnHolder->GetCellularDataStateMachine();
1068 apnHolder->GetCapability();
1069 apnHolder->GetPriority();
1070 apnHolder->InitialApnRetryCount();
1071 NetRequest request;
1072 request.ident = "test";
1073 request.capability = -1;
1074 apnHolder->RequestCellularData(request);
1075 apnHolder->ReleaseCellularData(request);
1076 apnHolder->RequestCellularData(request);
1077 apnHolder->ReleaseCellularData(request);
1078 ASSERT_FALSE(apnHolder->IsEmergencyType());
1079 ASSERT_FALSE(apnHolder->IsMmsType());
1080 EXPECT_GE(apnHolder->GetProfileId(DATA_CONTEXT_ROLE_DEFAULT), DATA_PROFILE_DEFAULT);
1081 EXPECT_GE(apnHolder->GetProfileId("test"), DATA_PROFILE_DEFAULT);
1082 }
1083
1084 /**
1085 * @tc.number Telephony_ApnHolder_002
1086 * @tc.name test error branch
1087 * @tc.desc Function test
1088 */
1089 HWTEST_F(BranchTest, Telephony_ApnHolder_002, Function | MediumTest | Level3)
1090 {
1091 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1092 std::vector<sptr<ApnItem>> newMatchedApns;
1093 std::vector<sptr<ApnItem>> oldMatchedApns;
1094 apnHolder->SetAllMatchedApns(oldMatchedApns);
1095 ASSERT_FALSE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1096 sptr<ApnItem> apnItemFirst = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1097 newMatchedApns.push_back(apnItemFirst);
1098 oldMatchedApns.push_back(apnItemFirst);
1099 apnHolder->SetAllMatchedApns(oldMatchedApns);
1100 ASSERT_TRUE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1101 sptr<ApnItem> apnItemSecond = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1102 newMatchedApns.push_back(apnItemSecond);
1103 ASSERT_FALSE(apnHolder->IsSameMatchedApns(newMatchedApns, true));
1104 }
1105
1106 /**
1107 * @tc.number Telephony_ApnHolder_003
1108 * @tc.name test error branch
1109 * @tc.desc Function test
1110 */
1111 HWTEST_F(BranchTest, Telephony_ApnHolder_003, Function | MediumTest | Level3)
1112 {
1113 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
1114 sptr<ApnItem> newApnItem;
1115 sptr<ApnItem> oldApnItem;
1116 ASSERT_FALSE(apnHolder->IsSameApnItem(newApnItem, oldApnItem, true));
1117 newApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1118 oldApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
1119 ASSERT_TRUE(apnHolder->IsSameApnItem(newApnItem, oldApnItem, true));
1120 oldApnItem->CanDealWithType(DATA_CONTEXT_ROLE_DEFAULT);
1121 oldApnItem->GetApnTypes();
1122 PdpProfile apnBean;
1123 oldApnItem->MakeApn(apnBean);
1124 oldApnItem->MarkBadApn(false);
1125 ASSERT_FALSE(oldApnItem->IsBadApn());
1126 }
1127
1128 /**
1129 * @tc.number NetworkSearchCallback_Test_01
1130 * @tc.name TestDump
1131 * @tc.desc Function test
1132 */
1133 HWTEST_F(BranchTest, NetworkSearchCallback_Test_01, Function | MediumTest | Level3)
1134 {
1135 auto networkSearchCallback = std::make_shared<NetworkSearchCallback>();
1136 networkSearchCallback->ClearCellularDataConnections(0);
1137 networkSearchCallback->ClearCellularDataConnections(-1);
1138 networkSearchCallback->HasInternetCapability(0, 0);
1139 ASSERT_FALSE(networkSearchCallback->HasInternetCapability(-1, -1));
1140 }
1141
1142 /**
1143 * @tc.number StateNotification_Test_01
1144 * @tc.name TestDump
1145 * @tc.desc Function test
1146 */
1147 HWTEST_F(BranchTest, StateNotification_Test_01, Function | MediumTest | Level3)
1148 {
1149 StateNotification::GetInstance().UpdateCellularDataConnectState(0, PROFILE_STATE_DISCONNECTING, 0);
1150 StateNotification::GetInstance().OnUpDataFlowtype(0, CellDataFlowType::DATA_FLOW_TYPE_NONE);
1151 StateNotification::GetInstance().OnUpDataFlowtype(1, CellDataFlowType::DATA_FLOW_TYPE_UP_DOWN);
1152 std::shared_ptr<CellularDataHandler> cellularDataHandler = nullptr;
1153 auto cellularDataRdbObserver = std::make_shared<CellularDataRdbObserver>(cellularDataHandler);
1154 cellularDataRdbObserver->OnChange();
1155 ASSERT_TRUE(cellularDataHandler == nullptr);
1156 }
1157
1158 /**
1159 * @tc.number Active_Test_01
1160 * @tc.name TestDump
1161 * @tc.desc Function test
1162 */
1163 HWTEST_F(BranchTest, Active_Test_01, Function | MediumTest | Level3)
1164 {
1165 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1166 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1167 cellularMachine->Init();
1168 auto active = static_cast<Active *>(cellularMachine->activeState_.GetRefPtr());
1169 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1170 active->stateMachine_ = stateMachine1;
1171 active->StateBegin();
1172 active->StateEnd();
1173 auto event = AppExecFwk::InnerEvent::Get(0);
1174 event = nullptr;
1175 active->RefreshTcpBufferSizes();
1176 active->RefreshConnectionBandwidths();
1177 active->ProcessConnectDone(event);
1178 ASSERT_FALSE(active->StateProcess(event));
1179 ASSERT_FALSE(active->ProcessDisconnectDone(event));
1180 ASSERT_FALSE(active->ProcessDisconnectAllDone(event));
1181 ASSERT_FALSE(active->ProcessLostConnection(event));
1182 ASSERT_FALSE(active->ProcessRilAdapterHostDied(event));
1183 ASSERT_FALSE(active->ProcessLinkCapabilityChanged(event));
1184 ASSERT_FALSE(active->ProcessNrStateChanged(event));
1185 ASSERT_FALSE(active->ProcessNrFrequencyChanged(event));
1186 ASSERT_FALSE(active->ProcessDataConnectionComplete(event));
1187 ASSERT_FALSE(active->ProcessDataConnectionVoiceCallStartedOrEnded(event));
1188 ASSERT_FALSE(active->ProcessDataConnectionRoamOn(event));
1189 ASSERT_FALSE(active->ProcessDataConnectionRoamOff(event));
1190 }
1191
1192 /**
1193 * @tc.number Activating_Test_01
1194 * @tc.name TestDump
1195 * @tc.desc Function test
1196 */
1197 HWTEST_F(BranchTest, Activating_Test_02, Function | MediumTest | Level3)
1198 {
1199 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1200 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1201 cellularMachine->Init();
1202 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
1203 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1204 activating->stateMachine_ = stateMachine1;
1205 activating->StateBegin();
1206 activating->StateEnd();
1207 auto event = AppExecFwk::InnerEvent::Get(0);
1208 event = nullptr;
1209 activating->ProcessConnectTimeout(event);
1210 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_RETRY);
1211 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_UNKNOWN);
1212 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_SHORTAGE_RESOURCES);
1213 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_ACTIVATION_REJECTED_UNSPECIFIED);
1214 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_SERVICE_OPTION_TEMPORARILY_OUT_OF_ORDER);
1215 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_APN_NOT_SUPPORTED_IN_CURRENT_RAT_PLMN);
1216 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_APN_RESTRICTION_VALUE_INCOMPATIBLE);
1217 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_MULT_ACCESSES_PDN_NOT_ALLOWED);
1218 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_OPERATOR_DETERMINED_BARRING);
1219 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_MISSING_OR_UNKNOWN_APN);
1220 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_UNKNOWN_PDP_ADDR_OR_TYPE);
1221 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_USER_VERIFICATION);
1222 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_ACTIVATION_REJECTED_GGSN);
1223 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_SERVICE_OPTION_NOT_SUPPORTED);
1224 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_REQUESTED_SERVICE_OPTION_NOT_SUBSCRIBED);
1225 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_NSAPI_ALREADY_USED);
1226 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_IPV4_ONLY_ALLOWED);
1227 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_IPV6_ONLY_ALLOWED);
1228 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_IPV4V6_ONLY_ALLOWED);
1229 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_NON_IP_ONLY_ALLOWED);
1230 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_MAX_NUM_OF_PDP_CONTEXTS);
1231 activating->DataCallPdpError(PdpErrorReason::PDP_ERR_PROTOCOL_ERRORS);
1232 activating->DataCallPdpError(-1);
1233 ASSERT_FALSE(activating->RilActivatePdpContextDone(event));
1234 ASSERT_FALSE(activating->RilErrorResponse(event));
1235 ASSERT_FALSE(activating->StateProcess(event));
1236 }
1237
1238 /**
1239 * @tc.number Inactive_Test_01
1240 * @tc.name TestDump
1241 * @tc.desc Function test
1242 */
1243 HWTEST_F(BranchTest, Inactive_Test_01, Function | MediumTest | Level3)
1244 {
1245 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1246 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1247 cellularMachine->Init();
1248 auto inactive = static_cast<Inactive *>(cellularMachine->inActiveState_.GetRefPtr());
1249 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1250 inactive->SetStateMachine(stateMachine1);
1251 auto event = AppExecFwk::InnerEvent::Get(0);
1252 event = nullptr;
1253 inactive->StateBegin();
1254 inactive->StateEnd();
1255 inactive->SetDeActiveApnTypeId(0);
1256 inactive->SetReason(DisConnectionReason::REASON_NORMAL);
1257 ASSERT_FALSE(inactive->StateProcess(event));
1258 }
1259
1260 /**
1261 * @tc.number Disconnecting_Test_01
1262 * @tc.name TestDump
1263 * @tc.desc Function test
1264 */
1265 HWTEST_F(BranchTest, Disconnecting_Test_01, Function | MediumTest | Level3)
1266 {
1267 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1268 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1269 cellularMachine->Init();
1270 auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
1271 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1272 disconnecting->stateMachine_ = stateMachine1;
1273 auto event = AppExecFwk::InnerEvent::Get(0);
1274 event = nullptr;
1275 disconnecting->StateBegin();
1276 disconnecting->StateEnd();
1277 disconnecting->ProcessDisconnectTimeout(event);
1278 disconnecting->ProcessRilAdapterHostDied(event);
1279 ASSERT_FALSE(disconnecting->StateProcess(event));
1280 }
1281
1282 /**
1283 * @tc.number Default_Test_01
1284 * @tc.name TestDump
1285 * @tc.desc Function test
1286 */
1287 HWTEST_F(BranchTest, Default_Test_01, Function | MediumTest | Level3)
1288 {
1289 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1290 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1291 cellularMachine->Init();
1292 auto mDefault = static_cast<Default *>(cellularMachine->defaultState_.GetRefPtr());
1293 std::weak_ptr<CellularDataStateMachine> stateMachine1;
1294 mDefault->stateMachine_ = stateMachine1;
1295 auto event = AppExecFwk::InnerEvent::Get(0);
1296 event = nullptr;
1297 mDefault->StateBegin();
1298 mDefault->StateEnd();
1299 ASSERT_FALSE(mDefault->StateProcess(event));
1300 ASSERT_FALSE(mDefault->ProcessConnectDone(event));
1301 ASSERT_FALSE(mDefault->ProcessDisconnectDone(event));
1302 ASSERT_FALSE(mDefault->ProcessDisconnectAllDone(event));
1303 ASSERT_FALSE(mDefault->ProcessDataConnectionDrsOrRatChanged(event));
1304 ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOn(event));
1305 ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOff(event));
1306 ASSERT_FALSE(mDefault->ProcessDataCallListChanged(event));
1307 }
1308
1309 /**
1310 * @tc.number ApnManager_Test_01
1311 * @tc.name TestDump
1312 * @tc.desc Function test
1313 */
1314 HWTEST_F(BranchTest, ApnManager_Test_01, Function | MediumTest | Level3)
1315 {
1316 auto apnManager = std::make_shared<ApnManager>();
1317 apnManager->CreateAllApnItem();
1318 EXPECT_GE(apnManager->CreateAllApnItemByDatabase(0), 0);
1319 EXPECT_EQ(apnManager->CreateAllApnItemByDatabase(0), 0);
1320 apnManager->ResetApns(0);
1321 std::string operatorNumeric = "46011";
1322 apnManager->GetCTOperator(0, operatorNumeric);
1323 EXPECT_EQ(operatorNumeric, "46011");
1324 apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
1325 apnManager->FindApnNameByApnId(1);
1326 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1327 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1328 cellularMachine->Init();
1329 ASSERT_TRUE(apnManager->IsDataConnectionNotUsed(cellularMachine));
1330 auto helper = CellularDataRdbHelper::GetInstance();
1331 helper->ResetApns(0);
1332 std::shared_ptr<DataShare::DataShareResultSet> result = nullptr;
1333 std::vector<PdpProfile> apnVec;
1334 helper->ReadMvnoApnResult(result, "", apnVec);
1335 PdpProfile apnBean;
1336 ASSERT_FALSE(helper->IsMvnoDataMatched("", apnBean));
1337 apnBean.mvnoType = MvnoType::ICCID;
1338 apnBean.mvnoMatchData = "test";
1339 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1340 apnBean.mvnoType = MvnoType::SPN;
1341 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1342 apnBean.mvnoType = MvnoType::GID1;
1343 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1344 apnBean.mvnoType = MvnoType::IMSI;
1345 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1346 apnBean.mvnoType = "error";
1347 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1348 helper->QueryPreferApn(0, apnVec);
1349 ASSERT_FALSE(helper->QueryPreferApn(-1, apnVec));
1350 }
1351
1352 /**
1353 * @tc.number IsMvnoDataMatched_Test_01
1354 * @tc.name Test IsMvnoDataMatched
1355 * @tc.desc Function test
1356 */
1357 HWTEST_F(BranchTest, IsMvnoDataMatched_Test_01, Function | MediumTest | Level3)
1358 {
1359 auto helper = CellularDataRdbHelper::GetInstance();
1360 PdpProfile apnBean;
1361 ASSERT_EQ(apnBean.mvnoMatchData, "");
1362 ASSERT_EQ(apnBean.mvnoType, "");
1363 ASSERT_FALSE(helper->IsMvnoDataMatched("", apnBean));
1364
1365 apnBean.mvnoType = MvnoType::ICCID;
1366 apnBean.mvnoMatchData = "";
1367 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1368
1369 apnBean.mvnoType = MvnoType::SPN;
1370 apnBean.mvnoMatchData = "\\";
1371 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1372
1373 apnBean.mvnoType = MvnoType::IMSI;
1374 apnBean.mvnoMatchData = "";
1375 ASSERT_FALSE(helper->IsMvnoDataMatched("test", apnBean));
1376
1377 apnBean.mvnoType = MvnoType::GID1;
1378 ASSERT_TRUE(helper->IsMvnoDataMatched("test", apnBean));
1379 }
1380
1381 /**
1382 * @tc.number IdleState_Test_01
1383 * @tc.name test error branch
1384 * @tc.desc Function test
1385 */
1386 HWTEST_F(BranchTest, Idle_Test_01, Function | MediumTest | Level3)
1387 {
1388 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1389 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1390 incallStateMachineTest->CreateIncallDataStateMachine(0);
1391 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1392 incallStateMachine->GetCurrentState();
1393 incallStateMachine->GetSlotId();
1394 incallStateMachine->GetCallState();
1395 incallStateMachine->HasAnyConnectedState();
1396 incallStateMachine->UpdateCallState(TelCallStatus::CALL_STATUS_ALERTING);
1397 incallStateMachine->IsIncallDataSwitchOn();
1398 incallStateMachine->IsSecondaryCanActiveData();
1399 incallStateMachine->CanActiveDataByRadioTech();
1400 auto idleState = static_cast<IdleState *>(incallStateMachine->idleState_.GetRefPtr());
1401 auto event = AppExecFwk::InnerEvent::Get(0);
1402 event = nullptr;
1403 idleState->StateBegin();
1404 ASSERT_FALSE(idleState->StateProcess(event));
1405 ASSERT_TRUE(idleState->ProcessCallStarted(event));
1406 ASSERT_TRUE(idleState->ProcessCallEnded(event));
1407 ASSERT_TRUE(idleState->ProcessSettingsOn(event));
1408 ASSERT_TRUE(idleState->ProcessDsdsChanged(event));
1409 idleState->StateEnd();
1410 }
1411
1412 /**
1413 * @tc.number ActivatingSecondaryState_Test_01
1414 * @tc.name test error branch
1415 * @tc.desc Function test
1416 */
1417 HWTEST_F(BranchTest, ActivatingSecondaryState_Test_01, Function | MediumTest | Level3)
1418 {
1419 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1420 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1421 incallStateMachineTest->CreateIncallDataStateMachine(0);
1422 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1423 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1424 auto activatingSecondaryState =
1425 static_cast<ActivatingSecondaryState *>(incallStateMachine->activatingSecondaryState_.GetRefPtr());
1426 auto secondaryActiveState =
1427 static_cast<SecondaryActiveState *>(incallStateMachine->secondaryActiveState_.GetRefPtr());
1428 auto event = AppExecFwk::InnerEvent::Get(0);
1429 event = nullptr;
1430 secondaryActiveState->StateBegin();
1431 activatingSecondaryState->StateBegin();
1432 ASSERT_FALSE(activatingSecondaryState->StateProcess(event));
1433 ASSERT_FALSE(secondaryActiveState->StateProcess(event));
1434 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOn(event));
1435 ASSERT_TRUE(secondaryActiveState->ProcessCallEnded(event));
1436 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOff(event));
1437 ASSERT_TRUE(secondaryActiveState->ProcessDsdsChanged(event));
1438 activatingSecondaryState->StateEnd();
1439 secondaryActiveState->StateEnd();
1440 }
1441
1442 /**
1443 * @tc.number ActivatedSecondaryState_Test_01
1444 * @tc.name test error branch
1445 * @tc.desc Function test
1446 */
1447 HWTEST_F(BranchTest, ActivatedSecondaryState_Test_01, Function | MediumTest | Level3)
1448 {
1449 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1450 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1451 incallStateMachineTest->CreateIncallDataStateMachine(0);
1452 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1453 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1454 incallStateMachine->TransitionTo(incallStateMachine->activatedSecondaryState_);
1455 auto activatedSecondaryState =
1456 static_cast<ActivatedSecondaryState *>(incallStateMachine->activatedSecondaryState_.GetRefPtr());
1457 auto secondaryActiveState =
1458 static_cast<SecondaryActiveState *>(incallStateMachine->secondaryActiveState_.GetRefPtr());
1459 auto event = AppExecFwk::InnerEvent::Get(0);
1460 event = nullptr;
1461 secondaryActiveState->StateBegin();
1462 activatedSecondaryState->StateBegin();
1463 ASSERT_FALSE(activatedSecondaryState->StateProcess(event));
1464 ASSERT_FALSE(secondaryActiveState->StateProcess(event));
1465 ASSERT_TRUE(secondaryActiveState->ProcessCallEnded(event));
1466 ASSERT_TRUE(secondaryActiveState->ProcessSettingsOff(event));
1467 activatedSecondaryState->StateEnd();
1468 secondaryActiveState->StateEnd();
1469 }
1470
1471 /**
1472 * @tc.number DeactivatingSecondaryState_Test_01
1473 * @tc.name test error branch
1474 * @tc.desc Function test
1475 */
1476 HWTEST_F(BranchTest, DeactivatingSecondaryState_Test_01, Function | MediumTest | Level3)
1477 {
1478 std::shared_ptr<IncallStateMachineTest> incallStateMachineTest = std::make_shared<IncallStateMachineTest>();
1479 std::shared_ptr<IncallDataStateMachine> incallStateMachine =
1480 incallStateMachineTest->CreateIncallDataStateMachine(0);
1481 incallStateMachine->Init(TelCallStatus::CALL_STATUS_DIALING);
1482 incallStateMachine->TransitionTo(incallStateMachine->activatingSecondaryState_);
1483 incallStateMachine->TransitionTo(incallStateMachine->activatedSecondaryState_);
1484 incallStateMachine->TransitionTo(incallStateMachine->deactivatingSecondaryState_);
1485 auto deactivatingSecondaryState =
1486 static_cast<DeactivatingSecondaryState *>(incallStateMachine->deactivatingSecondaryState_.GetRefPtr());
1487 auto event = AppExecFwk::InnerEvent::Get(0);
1488 event = nullptr;
1489 deactivatingSecondaryState->StateBegin();
1490 ASSERT_FALSE(deactivatingSecondaryState->StateProcess(event));
1491 deactivatingSecondaryState->StateEnd();
1492 }
1493
1494 /**
1495 * @tc.number GetIpType_Test_01
1496 * @tc.name TestDump
1497 * @tc.desc Function test
1498 */
1499 HWTEST_F(BranchTest, GetIpType_Test_01, Function | MediumTest | Level3)
1500 {
1501 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1502 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1503 cellularMachine->Init();
1504 std::string result = "";
1505 std::string address = "";
1506 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1507 result = cellularMachine->GetIpType(ipInfoArray);
1508 ASSERT_TRUE(result == "");
1509 }
1510
1511 /**
1512 * @tc.number DataSwitchSettings_Test_01
1513 * @tc.name test error branch
1514 * @tc.desc Function test
1515 */
1516 HWTEST_F(BranchTest, DataSwitchSettings_Test_01, Function | MediumTest | Level3)
1517 {
1518 std::unique_ptr<DataSwitchSettings> dataSwitchSettings = std::make_unique<DataSwitchSettings>(0);
1519 dataSwitchSettings->LoadSwitchValue();
1520 bool status = true;
1521 dataSwitchSettings->QueryUserDataStatus(status);
1522 dataSwitchSettings->QueryUserDataRoamingStatus(status);
1523 dataSwitchSettings->QueryIntelligenceSwitchStatus(status);
1524 dataSwitchSettings->SetPolicyDataOn(true);
1525 ASSERT_TRUE(dataSwitchSettings->IsPolicyDataOn());
1526 dataSwitchSettings->IsAllowActiveData();
1527 dataSwitchSettings->SetUserDataOn(true);
1528 dataSwitchSettings->IsUserDataOn();
1529 dataSwitchSettings->SetCarrierDataOn(true);
1530 ASSERT_TRUE(dataSwitchSettings->IsCarrierDataOn());
1531 dataSwitchSettings->SetUserDataRoamingOn(true);
1532 dataSwitchSettings->IsUserDataRoamingOn();
1533 dataSwitchSettings->SetInternalDataOn(true);
1534 ASSERT_TRUE(dataSwitchSettings->IsInternalDataOn());
1535 dataSwitchSettings->SetIntelliSwitchOn(true);
1536 dataSwitchSettings->UpdateUserDataRoamingOn(false);
1537 ASSERT_FALSE(dataSwitchSettings->IsUserDataRoamingOn());
1538 }
1539
1540 /**
1541 * @tc.number CellularDataStateMachine_Test_01
1542 * @tc.name test error branch
1543 * @tc.desc Function test
1544 */
1545 HWTEST_F(BranchTest, CellularDataStateMachine_Test_01, Function | MediumTest | Level3)
1546 {
1547 std::shared_ptr<StateMachineTest> machine = std::make_shared<StateMachineTest>();
1548 std::shared_ptr<CellularDataStateMachine> cellularMachine = machine->CreateCellularDataConnect(0);
1549 cellularMachine->IsInactiveState();
1550 uint64_t capability = 1;
1551 cellularMachine->SetCapability(capability);
1552 cellularMachine->GetCapability();
1553 const int32_t cid = 1;
1554 cellularMachine->SetCid(cid);
1555 cellularMachine->GetSlotId();
1556 cellularMachine->GetApnItem();
1557 cellularMachine->GetCurrentState();
1558 const uint32_t upBandwidth = 0;
1559 const uint32_t downBandwidth = 0;
1560 cellularMachine->SetConnectionBandwidth(upBandwidth, downBandwidth);
1561 const std::string tcpBuffer = "";
1562 cellularMachine->SetConnectionTcpBuffer(tcpBuffer);
1563 std::string proxyIpAddress = "1234:567";
1564 std::string host = "";
1565 uint16_t port = 0;
1566 cellularMachine->SplitProxyIpAddress(proxyIpAddress, host, port);
1567 EXPECT_EQ(host, "1234");
1568 EXPECT_EQ(port, 567);
1569 EXPECT_TRUE(cellularMachine != nullptr);
1570 CellularDataDumpHelper dumpHelper;
1571 std::string result = "";
1572 dumpHelper.ShowHelp(result);
1573 EXPECT_GE(result.size(), 0);
1574 }
1575
1576 /**
1577 * @tc.number CellularDataUtils_Test_01
1578 * @tc.name test error branch
1579 * @tc.desc Function test
1580 */
1581 HWTEST_F(BranchTest, CellularDataUtils_Test_01, Function | MediumTest | Level3)
1582 {
1583 CellularDataUtils::ParseNormalIpAddr(ADDRESS);
1584 CellularDataUtils::ParseRoute(ADDRESS);
1585 CellularDataUtils::GetPrefixLen(ADDRESS, FLAG);
1586 auto cellularDataHiSysEvent = DelayedSingleton<CellularDataHiSysEvent>::GetInstance();
1587 cellularDataHiSysEvent->WriteRoamingConnectStateBehaviorEvent(1);
1588 cellularDataHiSysEvent->SetCellularDataActivateStartTime();
1589 cellularDataHiSysEvent->JudgingDataActivateTimeOut(0, 1);
1590 std::shared_ptr<DataConnectionMonitor> dataConnectionMonitor = std::make_shared<DataConnectionMonitor>(0);
1591 dataConnectionMonitor->HandleRecovery();
1592 dataConnectionMonitor->GetPdpContextList();
1593 dataConnectionMonitor->SetRadioState(0, RadioEvent::RADIO_ON);
1594 dataConnectionMonitor->GetPreferredNetworkPara();
1595 dataConnectionMonitor->GetDataFlowType();
1596 dataConnectionMonitor->IsNeedDoRecovery(true);
1597 dataConnectionMonitor->IsNeedDoRecovery(false);
1598 auto cellularDataService = DelayedSingleton<CellularDataService>::GetInstance();
1599 MessageParcel data;
1600 MessageParcel reply;
1601 EXPECT_GE(cellularDataService->OnIsCellularDataEnabled(data, reply), 0);
1602 EXPECT_GE(cellularDataService->OnEnableCellularData(data, reply), 0);
1603 EXPECT_GE(cellularDataService->OnGetCellularDataState(data, reply), 0);
1604 EXPECT_GE(cellularDataService->OnIsCellularDataRoamingEnabled(data, reply), 0);
1605 EXPECT_GE(cellularDataService->OnEnableCellularDataRoaming(data, reply), 0);
1606 EXPECT_GE(cellularDataService->OnHandleApnChanged(data, reply), 0);
1607 cellularDataService->OnGetDefaultCellularDataSlotId(data, reply);
1608 EXPECT_GE(cellularDataService->OnGetDefaultCellularDataSimId(data, reply), 0);
1609 EXPECT_GE(cellularDataService->OnSetDefaultCellularDataSlotId(data, reply), 0);
1610 EXPECT_GE(cellularDataService->OnGetCellularDataFlowType(data, reply), 0);
1611 EXPECT_GE(cellularDataService->OnHasInternetCapability(data, reply), 0);
1612 EXPECT_GE(cellularDataService->OnClearCellularDataConnections(data, reply), 0);
1613 EXPECT_GE(cellularDataService->OnRegisterSimAccountCallback(data, reply), 0);
1614 EXPECT_GE(cellularDataService->OnUnregisterSimAccountCallback(data, reply), 0);
1615 EXPECT_GE(cellularDataService->OnEnableIntelligenceSwitch(data, reply), 0);
1616 EXPECT_GE(cellularDataService->OnGetDataConnApnAttr(data, reply), 0);
1617 EXPECT_GE(cellularDataService->OnGetDataConnIpType(data, reply), 0);
1618 EXPECT_GE(cellularDataService->OnGetApnState(data, reply), 0);
1619 EXPECT_GE(cellularDataService->OnGetRecoveryState(data, reply), 0);
1620 EXPECT_GE(cellularDataService->OnIsNeedDoRecovery(data, reply), 0);
1621 EXPECT_GE(cellularDataService->OnIsNeedDoRecovery(data, reply), 0);
1622 EXPECT_GE(cellularDataService->OnClearAllConnections(data, reply), 0);
1623 }
1624
1625 /**
1626 * @tc.number CellularDataSettingsRdbHelper_Test_01
1627 * @tc.name test error branch
1628 * @tc.desc Function test
1629 */
1630 HWTEST_F(BranchTest, CellularDataSettingsRdbHelper_Test_01, Function | MediumTest | Level3)
1631 {
1632 auto settingHelper = CellularDataSettingsRdbHelper::GetInstance();
1633 if (settingHelper == nullptr) {
1634 TELEPHONY_LOGE("settingHelper is null");
1635 return;
1636 }
1637 Uri dataEnableUri(CELLULAR_DATA_SETTING_DATA_ROAMING_URI);
1638 settingHelper->RegisterSettingsObserver(dataEnableUri, nullptr);
1639 settingHelper->UnRegisterSettingsObserver(dataEnableUri, nullptr);
1640 EXPECT_TRUE(settingHelper != nullptr);
1641 }
1642
1643 /**
1644 * @tc.number FindBestCapability_Test_01
1645 * @tc.name test branch
1646 * @tc.desc Function test
1647 */
1648 HWTEST_F(BranchTest, FindBestCapability_Test_01, Function | MediumTest | Level3)
1649 {
1650 auto apnManager = std::make_shared<ApnManager>();
1651
1652 uint64_t capabilities = 1L << NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET;
1653 auto ret = apnManager->FindBestCapability(capabilities);
1654 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
1655
1656 capabilities |= 1L << NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT;
1657 ret = apnManager->FindBestCapability(capabilities);
1658 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT);
1659
1660 capabilities |= 1L << NetManagerStandard::NetCap::NET_CAPABILITY_MMS;
1661 ret = apnManager->FindBestCapability(capabilities);
1662 EXPECT_EQ(ret, NetManagerStandard::NetCap::NET_CAPABILITY_MMS);
1663 }
1664
1665 /**
1666 * @tc.number GetOverallDefaultApnState_Test_01
1667 * @tc.name test branch
1668 * @tc.desc Function test
1669 */
1670 HWTEST_F(BranchTest, GetOverallDefaultApnState_Test_01, Function | MediumTest | Level3)
1671 {
1672 auto apnManager = std::make_shared<ApnManager>();
1673 apnManager->InitApnHolders();
1674 auto &apnHolders = apnManager->apnHolders_;
1675 for (auto &apnHolder : apnHolders) {
1676 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1677 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1678 }
1679 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1680 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1681 }
1682 }
1683 auto ret = apnManager->GetOverallDefaultApnState();
1684 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_IDLE);
1685
1686 for (auto &apnHolder : apnHolders) {
1687 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1688 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
1689 }
1690 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1691 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1692 }
1693 }
1694 ret = apnManager->GetOverallDefaultApnState();
1695 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
1696
1697 for (auto &apnHolder : apnHolders) {
1698 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1699 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_IDLE);
1700 }
1701 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1702 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
1703 }
1704 }
1705 ret = apnManager->GetOverallDefaultApnState();
1706 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
1707 }
1708
1709 /**
1710 * @tc.number GetOverallDefaultApnState_Test_02
1711 * @tc.name test branch
1712 * @tc.desc Function test
1713 */
1714 HWTEST_F(BranchTest, GetOverallDefaultApnState_Test_02, Function | MediumTest | Level3)
1715 {
1716 auto apnManager = std::make_shared<ApnManager>();
1717 apnManager->InitApnHolders();
1718 auto &apnHolders = apnManager->apnHolders_;
1719
1720 for (auto &apnHolder : apnHolders) {
1721 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1722 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTED);
1723 }
1724 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1725 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_DISCONNECTING);
1726 }
1727 }
1728 auto ret = apnManager->GetOverallDefaultApnState();
1729 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTED);
1730
1731 for (auto &apnHolder : apnHolders) {
1732 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1733 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTED);
1734 }
1735 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1736 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
1737 }
1738 }
1739 ret = apnManager->GetOverallDefaultApnState();
1740 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTED);
1741
1742 for (auto &apnHolder : apnHolders) {
1743 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
1744 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_CONNECTING);
1745 }
1746 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
1747 apnHolder->SetApnState(ApnProfileState::PROFILE_STATE_FAILED);
1748 }
1749 }
1750 ret = apnManager->GetOverallDefaultApnState();
1751 EXPECT_EQ(ret, ApnProfileState::PROFILE_STATE_CONNECTING);
1752 }
1753
1754 /**
1755 * @tc.number ParseIpAddr_001
1756 * @tc.name test branch
1757 * @tc.desc Function test
1758 */
1759 HWTEST_F(BranchTest, ParseIpAddr_001, Function | MediumTest | Level0)
1760 {
1761 std::string address = "";
1762 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1763 EXPECT_EQ(ipInfoArray.size(), 0);
1764 }
1765
1766 /**
1767 * @tc.number ParseIpAddr_002
1768 * @tc.name test branch
1769 * @tc.desc Function test
1770 */
1771 HWTEST_F(BranchTest, ParseIpAddr_002, Function | MediumTest | Level0)
1772 {
1773 std::string address = "192.000.1.1/24";
1774 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1775 EXPECT_EQ(ipInfoArray.size(), 1);
1776 }
1777
1778 /**
1779 * @tc.number ParseIpAddr_003
1780 * @tc.name test branch
1781 * @tc.desc Function test
1782 */
1783 HWTEST_F(BranchTest, ParseIpAddr_003, Function | MediumTest | Level0)
1784 {
1785 std::string address = "192.000.1.1/24 192.000.1.2/24";
1786 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1787 EXPECT_EQ(ipInfoArray.size(), 2);
1788 }
1789
1790 /**
1791 * @tc.number ParseIpAddr_004
1792 * @tc.name test branch
1793 * @tc.desc Function test
1794 */
1795 HWTEST_F(BranchTest, ParseIpAddr_004, Function | MediumTest | Level0)
1796 {
1797 std::string address = "2001:0000:0000:0000:0000:0000:0000:0000/64";
1798 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1799 EXPECT_EQ(ipInfoArray.size(), 1);
1800 }
1801
1802 /**
1803 * @tc.number ParseIpAddr_005
1804 * @tc.name test branch
1805 * @tc.desc Function test
1806 */
1807 HWTEST_F(BranchTest, ParseIpAddr_005, Function | MediumTest | Level0)
1808 {
1809 std::string address = "2001:0000:0000:0000:0000:0000:0000:0000/64 2001:0000:0000:0000:0000:0000:0000:0000/64";
1810 std::vector<AddressInfo> ipInfoArray = CellularDataUtils::ParseIpAddr(address);
1811 EXPECT_EQ(ipInfoArray.size(), 2);
1812 }
1813
1814 /**
1815 * @tc.number GetPrefixLen_001
1816 * @tc.name test branch
1817 * @tc.desc Function test
1818 */
1819 HWTEST_F(BranchTest, GetPrefixLen_001, Function | MediumTest | Level0)
1820 {
1821 std::vector<std::string> netmask;
1822 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1823 EXPECT_EQ(result, 0);
1824 }
1825
1826 /**
1827 * @tc.number GetPrefixLen_002
1828 * @tc.name test branch
1829 * @tc.desc Function test
1830 */
1831 HWTEST_F(BranchTest, GetPrefixLen_002, Function | MediumTest | Level0)
1832 {
1833 std::vector<std::string> netmask = {"255", "invalid", "255"};
1834 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1835 EXPECT_EQ(result, 8);
1836 }
1837
1838 /**
1839 * @tc.number GetPrefixLen_003
1840 * @tc.name test branch
1841 * @tc.desc Function test
1842 */
1843 HWTEST_F(BranchTest, GetPrefixLen_003, Function | MediumTest | Level0)
1844 {
1845 std::vector<std::string> netmask = {"255", "0", "255"};
1846 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1847 EXPECT_EQ(result, 8);
1848 }
1849
1850 /**
1851 * @tc.number GetPrefixLen_004
1852 * @tc.name test branch
1853 * @tc.desc Function test
1854 */
1855 HWTEST_F(BranchTest, GetPrefixLen_004, Function | MediumTest | Level0)
1856 {
1857 std::vector<std::string> netmask = {"255", "254", "255"};
1858 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1859 EXPECT_EQ(result, 15);
1860 }
1861
1862 /**
1863 * @tc.number GetPrefixLen_005
1864 * @tc.name test branch
1865 * @tc.desc Function test
1866 */
1867 HWTEST_F(BranchTest, GetPrefixLen_005, Function | MediumTest | Level0)
1868 {
1869 std::vector<std::string> netmask = {"255", "256", "255"};
1870 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1871 EXPECT_EQ(result, 8);
1872 }
1873
1874 /**
1875 * @tc.number GetPrefixLen_006
1876 * @tc.name test branch
1877 * @tc.desc Function test
1878 */
1879 HWTEST_F(BranchTest, GetPrefixLen_006, Function | MediumTest | Level0)
1880 {
1881 std::vector<std::string> netmask = {"255", "254", "255"};
1882 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1883 EXPECT_EQ(result, 15);
1884 }
1885
1886 /**
1887 * @tc.number GetPrefixLen_007
1888 * @tc.name test branch
1889 * @tc.desc Function test
1890 */
1891 HWTEST_F(BranchTest, GetPrefixLen_007, Function | MediumTest | Level0)
1892 {
1893 std::vector<std::string> netmask = {"255", "255", "255"};
1894 int32_t result = CellularDataUtils::GetPrefixLen(netmask, 0);
1895 EXPECT_EQ(result, 24);
1896 }
1897
1898 /**
1899 * @tc.number JudgingDataActivateTimeOut_001
1900 * @tc.name test branch
1901 * @tc.desc Function test
1902 */
1903 HWTEST_F(BranchTest, JudgingDataActivateTimeOut_001, Function | MediumTest | Level0)
1904 {
1905 auto cellularDataHiSysEvent = DelayedSingleton<CellularDataHiSysEvent>::GetInstance();
1906 int32_t slotId = 1;
1907 int32_t switchState = 1;
1908 cellularDataHiSysEvent->dataActivateStartTime_ = -1000;
1909 cellularDataHiSysEvent->JudgingDataActivateTimeOut(slotId, switchState);
1910 cellularDataHiSysEvent->SetCellularDataActivateStartTime();
1911 EXPECT_NE(cellularDataHiSysEvent->dataActivateStartTime_, -1000);
1912 }
1913
1914 /**
1915 * @tc.number ReadMvnoApnResult_001
1916 * @tc.name Test the function
1917 * @tc.desc Function test
1918 */
1919 HWTEST_F(BranchTest, ReadMvnoApnResult_001, TestSize.Level3)
1920 {
1921 std::shared_ptr<DataShare::DataShareResultSet> result = nullptr;
1922 std::string mvnoDataFromSim = "mvnoDataFromSim";
1923 std::vector<PdpProfile> apnVec;
1924 CellularDataRdbHelper cellularDataRdbHelper;
1925 cellularDataRdbHelper.ReadMvnoApnResult(nullptr, mvnoDataFromSim, apnVec);
1926 ASSERT_TRUE(apnVec.empty());
1927 }
1928
1929 /**
1930 * @tc.number ReadMvnoApnResult_002
1931 * @tc.name Test the function
1932 * @tc.desc Function test
1933 */
1934 HWTEST_F(BranchTest, ReadMvnoApnResult_002, TestSize.Level3)
1935 {
1936 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
1937 std::string mvnoDataFromSim = "mvnoDataFromSim";
1938 std::vector<PdpProfile> apnVec;
1939 CellularDataRdbHelper cellularDataRdbHelper;
1940 cellularDataRdbHelper.ReadMvnoApnResult(nullptr, mvnoDataFromSim, apnVec);
1941 ASSERT_TRUE(apnVec.empty());
1942 }
1943
1944 /**
1945 * @tc.number MakePdpProfile_001
1946 * @tc.name Test the function
1947 * @tc.desc Function test
1948 */
1949 HWTEST_F(BranchTest, MakePdpProfile_001, TestSize.Level3)
1950 {
1951 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
1952 int i = 0;
1953 PdpProfile apnBean;
1954 apnBean.pdpProtocol = "";
1955 apnBean.roamPdpProtocol = "";
1956 CellularDataRdbHelper cellularDataRdbHelper;
1957 cellularDataRdbHelper.MakePdpProfile(result, i, apnBean);
1958 ASSERT_EQ("IP", apnBean.pdpProtocol);
1959 ASSERT_EQ("IP", apnBean.roamPdpProtocol);
1960 }
1961
1962 /**
1963 * @tc.number MakePdpProfile_002
1964 * @tc.name Test the function
1965 * @tc.desc Function test
1966 */
1967 HWTEST_F(BranchTest, MakePdpProfile_002, TestSize.Level3)
1968 {
1969 std::shared_ptr<DataShare::DataShareResultSet> result = std::make_shared<DataShare::DataShareResultSet>();
1970 int i = 0;
1971 PdpProfile apnBean;
1972 apnBean.pdpProtocol = "ABC";
1973 apnBean.roamPdpProtocol = "abc";
1974 CellularDataRdbHelper cellularDataRdbHelper;
1975 cellularDataRdbHelper.MakePdpProfile(result, i, apnBean);
1976 ASSERT_EQ("ABC", apnBean.pdpProtocol);
1977 ASSERT_EQ("abc", apnBean.roamPdpProtocol);
1978 }
1979 } // namespace Telephony
1980 } // namespace OHOS
1981