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