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