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