1 /* 2 * Copyright (C) 2024 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 18 #include "gtest/gtest.h" 19 #include "common_event_manager.h" 20 #include "common_event_support.h" 21 #include "cellular_data_handler.h" 22 #include "cellular_data_controller.h" 23 24 namespace OHOS { 25 namespace Telephony { 26 using namespace testing::ext; 27 28 class CellularDataHandlerTest : public testing::Test { 29 public: SetUpTestCase()30 static void SetUpTestCase() {} TearDownTestCase()31 static void TearDownTestCase() {} SetUp()32 void SetUp() {} TearDown()33 void TearDown() {} 34 }; 35 36 /** 37 * @tc.number HandleUpdateNetInfo_001 38 * @tc.name test error branch 39 * @tc.desc Function test 40 */ 41 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_001, Function | MediumTest | Level3) 42 { 43 EventFwk::MatchingSkills matchingSkills; 44 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 45 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 46 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 47 auto netInfo = std::make_shared<SetupDataCallResultInfo>(); 48 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); 49 cellularDataHandler->HandleUpdateNetInfo(event); 50 EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr); 51 EXPECT_EQ(cellularDataHandler->apnManager_, nullptr); 52 } 53 54 /** 55 * @tc.number HandleUpdateNetInfo_002 56 * @tc.name test error branch 57 * @tc.desc Function test 58 */ 59 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_002, Function | MediumTest | Level3) 60 { 61 EventFwk::MatchingSkills matchingSkills; 62 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 63 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 64 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 65 cellularDataHandler->Init(); 66 auto netInfo = std::make_shared<SetupDataCallResultInfo>(); 67 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED); 68 cellularDataHandler->HandleUpdateNetInfo(event); 69 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 70 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 71 EXPECT_EQ(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr); 72 } 73 74 /** 75 * @tc.number HandleUpdateNetInfo_003 76 * @tc.name test error branch 77 * @tc.desc Function test 78 */ 79 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_003, Function | MediumTest | Level3) 80 { 81 EventFwk::MatchingSkills matchingSkills; 82 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 83 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 84 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 85 cellularDataHandler->Init(); 86 auto netInfo = std::make_shared<SetupDataCallResultInfo>(); 87 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID; 88 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); 89 cellularDataHandler->HandleUpdateNetInfo(event); 90 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 91 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 92 EXPECT_NE(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr); 93 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder( 94 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag)); 95 EXPECT_NE(apnHolder, nullptr); 96 EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_IDLE); 97 } 98 99 /** 100 * @tc.number HandleUpdateNetInfo_004 101 * @tc.name test error branch 102 * @tc.desc Function test 103 */ 104 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_004, Function | MediumTest | Level3) 105 { 106 EventFwk::MatchingSkills matchingSkills; 107 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 108 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 109 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 110 cellularDataHandler->Init(); 111 auto netInfo = std::make_shared<SetupDataCallResultInfo>(); 112 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID; 113 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder( 114 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag)); 115 EXPECT_NE(apnHolder, nullptr); 116 apnHolder->SetApnState(PROFILE_STATE_CONNECTED); 117 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); 118 cellularDataHandler->HandleUpdateNetInfo(event); 119 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 120 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 121 EXPECT_NE(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr); 122 EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTED); 123 auto stateMachine = cellularDataHandler->connectionManager_->GetActiveConnectionByCid(netInfo->cid); 124 EXPECT_EQ(stateMachine, nullptr); 125 } 126 127 /** 128 * @tc.number HandleUpdateNetInfo_005 129 * @tc.name test error branch 130 * @tc.desc Function test 131 */ 132 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_005, Function | MediumTest | Level3) 133 { 134 EventFwk::MatchingSkills matchingSkills; 135 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 136 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 137 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 138 cellularDataHandler->Init(); 139 auto netInfo = std::make_shared<SetupDataCallResultInfo>(); 140 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID; 141 netInfo->cid = 100; 142 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder( 143 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag)); 144 EXPECT_NE(apnHolder, nullptr); 145 apnHolder->SetApnState(PROFILE_STATE_CONNECTED); 146 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release(); 147 EXPECT_NE(connectionManager, nullptr); 148 connectionManager->Init(); 149 auto sm = std::make_shared<CellularDataStateMachine>( 150 connectionManager, std::make_shared<TelEventHandler>("CellularDataHandlerTest")); 151 sm->cid_ = 100; 152 cellularDataHandler->connectionManager_->AddActiveConnectionByCid(sm); 153 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); 154 cellularDataHandler->HandleUpdateNetInfo(event); 155 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 156 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 157 EXPECT_NE(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr); 158 EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTED); 159 auto stateMachine = cellularDataHandler->connectionManager_->GetActiveConnectionByCid(netInfo->cid); 160 EXPECT_NE(stateMachine, nullptr); 161 } 162 163 /** 164 * @tc.number HandleUpdateNetInfo_006 165 * @tc.name test error branch 166 * @tc.desc Function test 167 */ 168 HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_006, Function | MediumTest | Level3) 169 { 170 EventFwk::MatchingSkills matchingSkills; 171 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 172 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 173 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 174 cellularDataHandler->Init(); 175 auto netInfo = std::make_shared<SetupDataCallResultInfo>(); 176 netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID; 177 netInfo->cid = 100; 178 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder( 179 cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag)); 180 EXPECT_NE(apnHolder, nullptr); 181 apnHolder->SetApnState(PROFILE_STATE_IDLE); 182 cellularDataHandler->ClearConnection(apnHolder, DisConnectionReason::REASON_CLEAR_CONNECTION); 183 EXPECT_NE(apnHolder->GetApnState(), PROFILE_STATE_DISCONNECTING); 184 } 185 186 /** 187 * @tc.number HandleRoamingOff_001 188 * @tc.name test roaming off 189 * @tc.desc Function test 190 */ 191 HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_001, Function | MediumTest | Level3) 192 { 193 EventFwk::MatchingSkills matchingSkills; 194 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 195 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 196 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 197 EXPECT_NE(cellularDataHandler, nullptr); 198 cellularDataHandler->Init(); 199 cellularDataHandler->SetCellularDataRoamingEnabled(true); 200 auto event = AppExecFwk::InnerEvent::Get(0); 201 cellularDataHandler->RoamingStateOff(event); 202 } 203 204 /** 205 * @tc.number HandleRoamingOff_002 206 * @tc.name test roaming off 207 * @tc.desc Function test 208 */ 209 HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_002, Function | MediumTest | Level3) 210 { 211 EventFwk::MatchingSkills matchingSkills; 212 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 213 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 214 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 215 EXPECT_NE(cellularDataHandler, nullptr); 216 cellularDataHandler->Init(); 217 cellularDataHandler->SetCellularDataRoamingEnabled(false); 218 auto event = AppExecFwk::InnerEvent::Get(0); 219 cellularDataHandler->RoamingStateOff(event); 220 } 221 222 /** 223 * @tc.number HandleEstablishAllApnsIfConnectable_001 224 * @tc.name test error branch 225 * @tc.desc Function test 226 */ 227 HWTEST_F(CellularDataHandlerTest, HandleEstablishAllApnsIfConnectable_001, Function | MediumTest | Level3) 228 { 229 EventFwk::MatchingSkills matchingSkills; 230 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 231 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 232 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 233 cellularDataHandler->Init(); 234 AppExecFwk::InnerEvent::Pointer msgEvent = 235 AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_ESTABLISH_ALL_APNS_IF_CONNECTABLE); 236 cellularDataHandler->HandleEstablishAllApnsIfConnectable(msgEvent); 237 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 238 } 239 240 /** 241 * @tc.number HandleSimEvent_001 242 * @tc.name test error branch 243 * @tc.desc Function test 244 */ 245 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_001, Function | MediumTest | Level3) 246 { 247 EventFwk::MatchingSkills matchingSkills; 248 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 249 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 250 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 251 cellularDataHandler->Init(); 252 AppExecFwk::InnerEvent::Pointer nullEvent(nullptr, nullptr); 253 cellularDataHandler->HandleSimEvent(nullEvent); 254 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, 0); 255 cellularDataHandler->HandleSimEvent(event); 256 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 257 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 258 } 259 260 /** 261 * @tc.number HandleSimEvent_002 262 * @tc.name test error branch 263 * @tc.desc Function test 264 */ 265 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_002, Function | MediumTest | Level3) 266 { 267 EventFwk::MatchingSkills matchingSkills; 268 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 269 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 270 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 271 cellularDataHandler->Init(); 272 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 1); 273 cellularDataHandler->HandleSimEvent(event); 274 EXPECT_NE(cellularDataHandler->slotId_, event->GetParam()); 275 } 276 277 /** 278 * @tc.number HandleSimEvent_003 279 * @tc.name test error branch 280 * @tc.desc Function test 281 */ 282 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_003, Function | MediumTest | Level3) 283 { 284 EventFwk::MatchingSkills matchingSkills; 285 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 286 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 287 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 288 cellularDataHandler->Init(); 289 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 0); 290 cellularDataHandler->HandleSimEvent(event); 291 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_STATE_CHANGE); 292 } 293 294 /** 295 * @tc.number HandleSimEvent_004 296 * @tc.name test error branch 297 * @tc.desc Function test 298 */ 299 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_004, Function | MediumTest | Level3) 300 { 301 EventFwk::MatchingSkills matchingSkills; 302 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 303 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 304 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 305 cellularDataHandler->Init(); 306 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_RECORDS_LOADED, 0); 307 cellularDataHandler->HandleSimEvent(event); 308 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_RECORDS_LOADED); 309 } 310 311 /** 312 * @tc.number HandleSimEvent_005 313 * @tc.name test error branch 314 * @tc.desc Function test 315 */ 316 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_005, Function | MediumTest | Level3) 317 { 318 EventFwk::MatchingSkills matchingSkills; 319 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 320 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 321 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 322 cellularDataHandler->Init(); 323 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NV_REFRESH_FINISHED, 0); 324 cellularDataHandler->HandleSimEvent(event); 325 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_NV_REFRESH_FINISHED); 326 } 327 328 /** 329 * @tc.number HandleSimEvent_006 330 * @tc.name test error branch 331 * @tc.desc Function test 332 */ 333 HWTEST_F(CellularDataHandlerTest, HandleSimEvent_006, Function | MediumTest | Level3) 334 { 335 EventFwk::MatchingSkills matchingSkills; 336 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 337 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 338 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 339 cellularDataHandler->Init(); 340 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ACCOUNT_LOADED, 0); 341 cellularDataHandler->HandleSimEvent(event); 342 EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_ACCOUNT_LOADED); 343 } 344 345 /** 346 * @tc.number ClearConnectionsOnUpdateApns_001 347 * @tc.name test error branch 348 * @tc.desc Function test 349 */ 350 HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_001, Function | MediumTest | Level3) 351 { 352 EventFwk::MatchingSkills matchingSkills; 353 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 354 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 355 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 356 cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION); 357 EXPECT_EQ(cellularDataHandler->apnManager_, nullptr); 358 } 359 360 /** 361 * @tc.number ClearConnectionsOnUpdateApns_002 362 * @tc.name test error branch 363 * @tc.desc Function test 364 */ 365 HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_002, Function | MediumTest | Level3) 366 { 367 EventFwk::MatchingSkills matchingSkills; 368 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 369 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 370 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 371 cellularDataHandler->Init(); 372 cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION); 373 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 374 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 375 cellularDataHandler->apnManager_->allApnItem_.clear(); 376 cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION); 377 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 378 std::vector<sptr<ApnItem>> allApnItem; 379 sptr<ApnItem> defaultApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT); 380 allApnItem.push_back(defaultApnItem); 381 cellularDataHandler->apnManager_->allApnItem_ = allApnItem; 382 EXPECT_NE(cellularDataHandler->apnManager_->GetRilAttachApn(), nullptr); 383 cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION); 384 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 385 } 386 387 /** 388 * @tc.number CellularDataHandler_Uid_Test001 389 * @tc.name test error branch 390 * @tc.desc Function test 391 */ 392 HWTEST_F(CellularDataHandlerTest, CellularDataHandler_Uid_Test001, Function | MediumTest | Level3) 393 { 394 EventFwk::MatchingSkills matchingSkills; 395 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 396 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 397 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 398 NetRequest netRequest; 399 netRequest.capability = 1; 400 netRequest.ident = "ident"; 401 EXPECT_FALSE(cellularDataHandler->AddUid(netRequest)); 402 EXPECT_FALSE(cellularDataHandler->RemoveUid(netRequest)); 403 cellularDataHandler->Init(); 404 EXPECT_TRUE(cellularDataHandler->AddUid(netRequest)); 405 EXPECT_TRUE(cellularDataHandler->RemoveUid(netRequest)); 406 } 407 408 /** 409 * @tc.number SetCellularDataRoamingEnabledTest001 410 * @tc.name test error branch 411 * @tc.desc Function test 412 */ 413 HWTEST_F(CellularDataHandlerTest, SetCellularDataRoamingEnabledTest001, Function | MediumTest | Level3) 414 { 415 EventFwk::MatchingSkills matchingSkills; 416 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 417 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 418 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 419 bool dataRoamingEnabled = true; 420 EXPECT_EQ(cellularDataHandler->SetCellularDataRoamingEnabled(dataRoamingEnabled), TELEPHONY_ERR_LOCAL_PTR_NULL); 421 cellularDataHandler->Init(); 422 auto event = AppExecFwk::InnerEvent::Get(0); 423 cellularDataHandler->RadioPsConnectionAttached(event); 424 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 425 cellularDataHandler->RoamingStateOn(event); 426 cellularDataHandler->RoamingStateOff(event); 427 EXPECT_NE(cellularDataHandler->dataSwitchSettings_, nullptr); 428 cellularDataHandler->incallDataStateMachine_ = cellularDataHandler->CreateIncallDataStateMachine(0); 429 EXPECT_FALSE(cellularDataHandler->SetDataPermittedForMms(true)); 430 } 431 432 /** 433 * @tc.number AttemptEstablishDataConnectionTest001 434 * @tc.name test error branch 435 * @tc.desc Function test 436 */ 437 HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest001, Function | MediumTest | Level3) 438 { 439 EventFwk::MatchingSkills matchingSkills; 440 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 441 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 442 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 443 cellularDataHandler->Init(); 444 std::shared_ptr<CellularDataStateMachine> cellularMachine = nullptr; 445 cellularDataHandler->connectionManager_->GetAllConnectionMachine().push_back(cellularMachine); 446 EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr); 447 } 448 449 /** 450 * @tc.number AttemptEstablishDataConnectionTest002 451 * @tc.name test error branch 452 * @tc.desc Function test 453 */ 454 HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest002, Function | MediumTest | Level3) 455 { 456 EventFwk::MatchingSkills matchingSkills; 457 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 458 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 459 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 460 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release(); 461 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>( 462 connectionManager, nullptr); 463 cellularDataHandler->connectionManager_ = connectionManager; 464 cellularDataHandler->connectionManager_->GetAllConnectionMachine().push_back(cellularMachine); 465 EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr); 466 cellularDataHandler->Init(); 467 EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr); 468 } 469 470 /** 471 * @tc.number EstablishDataConnectionTest002 472 * @tc.name test error branch 473 * @tc.desc Function test 474 */ 475 HWTEST_F(CellularDataHandlerTest, EstablishDataConnectionTest002, Function | MediumTest | Level3) 476 { 477 EventFwk::MatchingSkills matchingSkills; 478 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 479 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 480 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 481 cellularDataHandler->Init(); 482 sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT); 483 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 484 apnHolder->retryPolicy_.matchedApns_.push_back(apnItem); 485 EXPECT_NE(apnHolder->GetNextRetryApn(), nullptr); 486 EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0)); 487 apnHolder->apnType_ = DATA_CONTEXT_ROLE_DUN; 488 EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0)); 489 apnHolder->apnType_ = DATA_CONTEXT_ROLE_MMS; 490 EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0)); 491 } 492 493 /** 494 * @tc.number DisconnectDataCompleteTest001 495 * @tc.name test error branch 496 * @tc.desc Function test 497 */ 498 HWTEST_F(CellularDataHandlerTest, DisconnectDataCompleteTest001, Function | MediumTest | Level3) 499 { 500 EventFwk::MatchingSkills matchingSkills; 501 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 502 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 503 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 504 cellularDataHandler->Init(); 505 auto event = AppExecFwk::InnerEvent::Get(0); 506 cellularDataHandler->DisconnectDataComplete(event); 507 EXPECT_NE(event, nullptr); 508 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 509 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 510 } 511 512 /** 513 * @tc.number UpdatePhysicalConnectionStateTest001 514 * @tc.name test error branch 515 * @tc.desc Function test 516 */ 517 HWTEST_F(CellularDataHandlerTest, UpdatePhysicalConnectionStateTest001, Function | MediumTest | Level3) 518 { 519 EventFwk::MatchingSkills matchingSkills; 520 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 521 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 522 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 523 cellularDataHandler->physicalConnectionActiveState_ = false; 524 cellularDataHandler->UpdatePhysicalConnectionState(false); 525 EXPECT_TRUE(cellularDataHandler->physicalConnectionActiveState_); 526 527 cellularDataHandler->UpdatePhysicalConnectionState(true); 528 EXPECT_FALSE(cellularDataHandler->physicalConnectionActiveState_); 529 530 cellularDataHandler->physicalConnectionActiveState_ = true; 531 cellularDataHandler->UpdatePhysicalConnectionState(false); 532 EXPECT_TRUE(cellularDataHandler->physicalConnectionActiveState_); 533 534 cellularDataHandler->UpdatePhysicalConnectionState(true); 535 EXPECT_FALSE(cellularDataHandler->physicalConnectionActiveState_); 536 } 537 538 /** 539 * @tc.number HandleScreenStateChangedTest001 540 * @tc.name test error branch 541 * @tc.desc Function test 542 */ 543 HWTEST_F(CellularDataHandlerTest, HandleScreenStateChangedTest001, Function | MediumTest | Level3) 544 { 545 EventFwk::MatchingSkills matchingSkills; 546 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 547 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 548 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 549 cellularDataHandler->HandleScreenStateChanged(false); 550 EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr); 551 cellularDataHandler->Init(); 552 cellularDataHandler->HandleScreenStateChanged(false); 553 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 554 } 555 556 /** 557 * @tc.number UpdateCellularDataConnectStateTest001 558 * @tc.name test error branch 559 * @tc.desc Function test 560 */ 561 HWTEST_F(CellularDataHandlerTest, UpdateCellularDataConnectStateTest001, Function | MediumTest | Level3) 562 { 563 EventFwk::MatchingSkills matchingSkills; 564 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 565 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 566 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 567 cellularDataHandler->Init(); 568 cellularDataHandler->incallDataStateMachine_ = cellularDataHandler->CreateIncallDataStateMachine(0); 569 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr); 570 cellularDataHandler->IncallDataComplete(event); 571 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr); 572 cellularDataHandler->UpdateCellularDataConnectState("default"); 573 EXPECT_EQ(cellularDataHandler->apnManager_->GetOverallDefaultApnState(), 0); 574 cellularDataHandler->UpdateCellularDataConnectState("internal_default"); 575 EXPECT_EQ(cellularDataHandler->apnManager_->GetOverallDefaultApnState(), 0); 576 } 577 578 /** 579 * @tc.number HandleImsCallChangedTest001 580 * @tc.name test error branch 581 * @tc.desc Function test 582 */ 583 HWTEST_F(CellularDataHandlerTest, HandleImsCallChangedTest001, Function | MediumTest | Level3) 584 { 585 EventFwk::MatchingSkills matchingSkills; 586 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 587 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 588 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 589 cellularDataHandler->Init(); 590 cellularDataHandler->HandleImsCallChanged(1); 591 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr); 592 cellularDataHandler->HandleImsCallChanged(4); 593 EXPECT_NE(cellularDataHandler->incallDataStateMachine_, nullptr); 594 cellularDataHandler->HandleImsCallChanged(2); 595 EXPECT_NE(cellularDataHandler->incallDataStateMachine_->GetCallState(), 8); 596 cellularDataHandler->HandleImsCallChanged(4); 597 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 4); 598 cellularDataHandler->HandleImsCallChanged(6); 599 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 6); 600 cellularDataHandler->HandleImsCallChanged(8); 601 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 8); 602 } 603 604 /** 605 * @tc.number PsDataRatChangedTest001 606 * @tc.name test error branch 607 * @tc.desc Function test 608 */ 609 HWTEST_F(CellularDataHandlerTest, PsDataRatChangedTest001, Function | MediumTest | Level3) 610 { 611 EventFwk::MatchingSkills matchingSkills; 612 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 613 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 614 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 615 cellularDataHandler->Init(); 616 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr); 617 cellularDataHandler->PsDataRatChanged(event); 618 cellularDataHandler->dataSwitchSettings_->userDataOn_ = false; 619 EXPECT_FALSE(cellularDataHandler->dataSwitchSettings_->IsUserDataOn()); 620 } 621 622 /** 623 * @tc.number SetPolicyDataOnTest001 624 * @tc.name test error branch 625 * @tc.desc Function test 626 */ 627 HWTEST_F(CellularDataHandlerTest, SetPolicyDataOnTest001, Function | MediumTest | Level3) 628 { 629 EventFwk::MatchingSkills matchingSkills; 630 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 631 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 632 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 633 cellularDataHandler->Init(); 634 cellularDataHandler->dataSwitchSettings_->policyDataOn_ = false; 635 cellularDataHandler->SetPolicyDataOn(true); 636 EXPECT_TRUE(cellularDataHandler->dataSwitchSettings_->IsUserDataOn()); 637 cellularDataHandler->dataSwitchSettings_->policyDataOn_ = true; 638 cellularDataHandler->SetPolicyDataOn(false); 639 EXPECT_FALSE(cellularDataHandler->dataSwitchSettings_->policyDataOn_); 640 } 641 642 /** 643 * @tc.number SetRilAttachApnTest001 644 * @tc.name test error branch 645 * @tc.desc Function test 646 */ 647 HWTEST_F(CellularDataHandlerTest, SetRilAttachApnTest001, Function | MediumTest | Level3) 648 { 649 EventFwk::MatchingSkills matchingSkills; 650 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 651 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 652 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 653 cellularDataHandler->Init(); 654 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 655 sptr<ApnItem> attachApn = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT); 656 cellularDataHandler->apnManager_->allApnItem_.push_back(attachApn); 657 cellularDataHandler->SetRilAttachApn(); 658 } 659 660 /** 661 * @tc.number HasAnyHigherPriorityConnectionTest001 662 * @tc.name test error branch 663 * @tc.desc Function test 664 */ 665 HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest001, Function | MediumTest | Level3) 666 { 667 EventFwk::MatchingSkills matchingSkills; 668 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 669 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 670 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 671 cellularDataHandler->Init(); 672 sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 673 sortApnHolder->priority_ = 1; 674 sortApnHolder->dataCallEnabled_ = true; 675 sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_CONNECTED; 676 cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder); 677 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 678 apnHolder->priority_ = 0; 679 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 680 EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true); 681 EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder)); 682 } 683 684 /** 685 * @tc.number HasAnyHigherPriorityConnectionTest002 686 * @tc.name test error branch 687 * @tc.desc Function test 688 */ 689 HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest002, Function | MediumTest | Level3) 690 { 691 EventFwk::MatchingSkills matchingSkills; 692 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 693 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 694 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 695 cellularDataHandler->Init(); 696 sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 697 sortApnHolder->priority_ = 1; 698 sortApnHolder->dataCallEnabled_ = true; 699 sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_CONNECTING; 700 cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder); 701 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 702 apnHolder->priority_ = 0; 703 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 704 EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true); 705 EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder)); 706 } 707 708 /** 709 * @tc.number HasAnyHigherPriorityConnectionTest003 710 * @tc.name test error branch 711 * @tc.desc Function test 712 */ 713 HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest003, Function | MediumTest | Level3) 714 { 715 EventFwk::MatchingSkills matchingSkills; 716 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 717 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 718 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 719 cellularDataHandler->Init(); 720 sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 721 sortApnHolder->priority_ = 1; 722 sortApnHolder->dataCallEnabled_ = true; 723 sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_DISCONNECTING; 724 cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder); 725 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 726 apnHolder->priority_ = 0; 727 EXPECT_NE(cellularDataHandler->apnManager_, nullptr); 728 EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true); 729 EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder)); 730 } 731 732 /** 733 * @tc.number HasInternetCapabilityTest001 734 * @tc.name test error branch 735 * @tc.desc Function test 736 */ 737 HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest001, Function | MediumTest | Level3) 738 { 739 EventFwk::MatchingSkills matchingSkills; 740 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 741 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 742 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 743 cellularDataHandler->Init(); 744 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release(); 745 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>( 746 connectionManager, nullptr); 747 cellularMachine->capability_ = NetCap::NET_CAPABILITY_INTERNET; 748 cellularDataHandler->connectionManager_->cidActiveConnectionMap_[0] = cellularMachine; 749 EXPECT_NE(cellularDataHandler->connectionManager_->GetActiveConnectionByCid(0), nullptr); 750 EXPECT_TRUE(cellularDataHandler->HasInternetCapability(0)); 751 } 752 753 /** 754 * @tc.number HasInternetCapabilityTest002 755 * @tc.name test error branch 756 * @tc.desc Function test 757 */ 758 HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest002, Function | MediumTest | Level3) 759 { 760 EventFwk::MatchingSkills matchingSkills; 761 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 762 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 763 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 764 cellularDataHandler->Init(); 765 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release(); 766 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>( 767 connectionManager, nullptr); 768 cellularMachine->capability_ = NetCap::NET_CAPABILITY_MMS; 769 cellularDataHandler->connectionManager_->cidActiveConnectionMap_[0] = cellularMachine; 770 EXPECT_NE(cellularDataHandler->connectionManager_->GetActiveConnectionByCid(0), nullptr); 771 EXPECT_FALSE(cellularDataHandler->HasInternetCapability(0)); 772 } 773 774 /** 775 * @tc.number ChangeConnectionForDsdsTest001 776 * @tc.name test error branch 777 * @tc.desc Function test 778 */ 779 HWTEST_F(CellularDataHandlerTest, ChangeConnectionForDsdsTest001, Function | MediumTest | Level3) 780 { 781 EventFwk::MatchingSkills matchingSkills; 782 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 783 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 784 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 785 cellularDataHandler->Init(); 786 cellularDataHandler->ChangeConnectionForDsds(true); 787 EXPECT_TRUE(cellularDataHandler->dataSwitchSettings_->internalDataOn_); 788 } 789 790 /** 791 * @tc.number GetDataConnApnAttrTest001 792 * @tc.name test error branch 793 * @tc.desc Function test 794 */ 795 HWTEST_F(CellularDataHandlerTest, GetDataConnApnAttrTest001, Function | MediumTest | Level3) 796 { 797 EventFwk::MatchingSkills matchingSkills; 798 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 799 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 800 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 801 cellularDataHandler->Init(); 802 sptr<ApnHolder> apnHolder1 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 803 apnHolder1->apnItem_ = nullptr; 804 apnHolder1->dataCallEnabled_ = true; 805 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder1); 806 sptr<ApnHolder> apnHolder2 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 807 sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT); 808 apnItem->attr_.isEdited_ = true; 809 apnHolder2->apnItem_ = apnItem; 810 apnHolder2->dataCallEnabled_ = true; 811 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder2); 812 ApnItem::Attribute apnAttr; 813 apnAttr.isEdited_ = false; 814 cellularDataHandler->GetDataConnApnAttr(apnAttr); 815 EXPECT_TRUE(apnAttr.isEdited_); 816 } 817 818 /** 819 * @tc.number GetDataConnIpTypeTest001 820 * @tc.name test error branch 821 * @tc.desc Function test 822 */ 823 HWTEST_F(CellularDataHandlerTest, GetDataConnIpTypeTest001, Function | MediumTest | Level3) 824 { 825 EventFwk::MatchingSkills matchingSkills; 826 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 827 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 828 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 829 cellularDataHandler->Init(); 830 sptr<ApnHolder> apnHolder1 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 831 apnHolder1->cellularDataStateMachine_ = nullptr; 832 apnHolder1->dataCallEnabled_ = true; 833 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder1); 834 sptr<ApnHolder> apnHolder2 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 835 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release(); 836 std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>( 837 connectionManager, nullptr); 838 cellularMachine->ipType_ = "IPV4"; 839 apnHolder2->cellularDataStateMachine_ = cellularMachine; 840 apnHolder2->dataCallEnabled_ = true; 841 cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder2); 842 cellularDataHandler->GetDataConnIpType(); 843 EXPECT_EQ(cellularDataHandler->GetDataConnIpType(), "IPV4"); 844 } 845 846 /** 847 * @tc.number CheckForCompatibleDataConnectionTest001 848 * @tc.name test error branch 849 * @tc.desc Function test 850 */ 851 HWTEST_F(CellularDataHandlerTest, CheckForCompatibleDataConnectionTest001, Function | MediumTest | Level3) 852 { 853 EventFwk::MatchingSkills matchingSkills; 854 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 855 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 856 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); 857 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 858 apnHolder->apnType_ = DATA_CONTEXT_ROLE_DUN; 859 EXPECT_EQ(cellularDataHandler->CheckForCompatibleDataConnection(apnHolder), nullptr); 860 cellularDataHandler->Init(); 861 EXPECT_EQ(cellularDataHandler->CheckForCompatibleDataConnection(apnHolder), nullptr); 862 } 863 864 /** 865 * @tc.number ReleaseCellularDataConnectionTest001 866 * @tc.name test error branch 867 * @tc.desc Function test 868 */ 869 HWTEST_F(CellularDataHandlerTest, ReleaseCellularDataConnectionTest001, Function | MediumTest | Level3) 870 { 871 EventFwk::MatchingSkills matchingSkills; 872 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 873 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 874 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 875 cellularDataHandler->Init(); 876 std::set<uint32_t> reqUids = {1}; 877 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release(); 878 apnHolder->reqUids_ = reqUids; 879 cellularDataHandler->apnManager_->apnIdApnHolderMap_[1] = apnHolder; 880 cellularDataHandler->ReleaseCellularDataConnection(); 881 EXPECT_NE(cellularDataHandler->apnManager_->apnIdApnHolderMap_[1]->apnState_, 3); 882 } 883 884 /** 885 * @tc.number UpdateNetworkInfo_001 886 * @tc.name test error branch 887 * @tc.desc Function test 888 */ 889 HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_001, Function | MediumTest | Level3) 890 { 891 EventFwk::MatchingSkills matchingSkills; 892 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 893 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 894 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 895 EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr); 896 EXPECT_FALSE(cellularDataHandler->UpdateNetworkInfo()); 897 } 898 899 /** 900 * @tc.number UpdateNetworkInfo_002 901 * @tc.name test error branch 902 * @tc.desc Function test 903 */ 904 HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_002, Function | MediumTest | Level3) 905 { 906 EventFwk::MatchingSkills matchingSkills; 907 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 908 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 909 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 910 cellularDataHandler->Init(); 911 EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); 912 EXPECT_TRUE(cellularDataHandler->UpdateNetworkInfo()); 913 } 914 915 /** 916 * @tc.number AddUid001 917 * @tc.name test error branch 918 * @tc.desc Function test 919 */ 920 HWTEST_F(CellularDataHandlerTest, AddUid001, Function | MediumTest | Level3) 921 { 922 EventFwk::MatchingSkills matchingSkills; 923 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 924 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 925 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 926 cellularDataHandler->Init(); 927 NetRequest request; 928 request.uid = 1; 929 EXPECT_FALSE(cellularDataHandler->AddUid(request)); 930 cellularDataHandler->apnManager_ = nullptr; 931 EXPECT_FALSE(cellularDataHandler->AddUid(request)); 932 } 933 934 /** 935 * @tc.number RemoveUid001 936 * @tc.name test error branch 937 * @tc.desc Function test 938 */ 939 HWTEST_F(CellularDataHandlerTest, RemoveUid001, Function | MediumTest | Level3) 940 { 941 EventFwk::MatchingSkills matchingSkills; 942 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 943 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 944 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 945 cellularDataHandler->Init(); 946 NetRequest request; 947 request.uid = 1; 948 EXPECT_FALSE(cellularDataHandler->RemoveUid(request)); 949 cellularDataHandler->apnManager_ = nullptr; 950 EXPECT_FALSE(cellularDataHandler->RemoveUid(request)); 951 } 952 953 /** 954 * @tc.number Telephony_GetCurrentApnId_Test_01 955 * @tc.name test error branch 956 * @tc.desc Function test 957 */ 958 HWTEST_F(CellularDataHandlerTest, GetCurrentApnId_Test_01, Function | MediumTest | Level1) 959 { 960 EventFwk::MatchingSkills matchingSkills; 961 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 962 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 963 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 964 cellularDataHandler->Init(); 965 int32_t profileId = cellularDataHandler->GetCurrentApnId(); 966 EXPECT_NE(profileId, 0); 967 } 968 969 /** 970 * @tc.number Telephony_FindApnHolderById_Test_01 971 * @tc.name test error branch 972 * @tc.desc Function test 973 */ 974 HWTEST_F(CellularDataHandlerTest, FindApnHolderById_Test_01, Function | MediumTest | Level1) 975 { 976 EventFwk::MatchingSkills matchingSkills; 977 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 978 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 979 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 980 cellularDataHandler->Init(); 981 int32_t profileId = cellularDataHandler->GetCurrentApnId(); 982 EXPECT_NE(profileId, 0); 983 EXPECT_NE(cellularDataHandler->apnManager_->FindApnHolderById(profileId), nullptr); 984 } 985 986 /** 987 * @tc.number Telephony_CellularDataHandler_001 988 * @tc.name test error branch 989 * @tc.desc Function test 990 */ 991 HWTEST_F(CellularDataHandlerTest, Telephony_CellularDataHandler_001, Function | MediumTest | Level1) 992 { 993 CellularDataController controller {0}; 994 controller.Init(); 995 NetRequest request; 996 request.ident = "simId1"; 997 EXPECT_FALSE(controller.AddUid(request)); 998 controller.cellularDataHandler_ = nullptr; 999 EXPECT_FALSE(controller.AddUid(request)); 1000 } 1001 1002 /** 1003 * @tc.number Telephony_CellularDataHandler_002 1004 * @tc.name test error branch 1005 * @tc.desc Function test 1006 */ 1007 HWTEST_F(CellularDataHandlerTest, Telephony_CellularDataHandler_002, Function | MediumTest | Level1) 1008 { 1009 CellularDataController controller {0}; 1010 controller.Init(); 1011 NetRequest request; 1012 request.ident = "simId1"; 1013 EXPECT_FALSE(controller.RemoveUid(request)); 1014 controller.cellularDataHandler_ = nullptr; 1015 EXPECT_FALSE(controller.RemoveUid(request)); 1016 } 1017 1018 /** 1019 * @tc.number Telephony_MsgRequest 1020 * @tc.name test error branch 1021 * @tc.desc Function test 1022 */ 1023 HWTEST_F(CellularDataHandlerTest, Telephony_MsgRequest, Function | MediumTest | Level1) 1024 { 1025 EventFwk::MatchingSkills matchingSkills; 1026 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 1027 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 1028 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 1029 cellularDataHandler->Init(); 1030 NetRequest request1; 1031 request1.capability = NetManagerStandard::NET_CAPABILITY_INTERNET; 1032 request1.registerType = REGISTER; 1033 1034 EXPECT_TRUE(cellularDataHandler->RequestNet(request1)); 1035 NetRequest request2; 1036 request2.capability = NetManagerStandard::NET_CAPABILITY_INTERNET; 1037 request2.registerType = REQUEST; 1038 EXPECT_TRUE(cellularDataHandler->RequestNet(request2)); 1039 sleep(2); 1040 } 1041 1042 /** 1043 * @tc.number Telephony_ConnectIfNeed 1044 * @tc.name test error branch 1045 * @tc.desc Function test 1046 */ 1047 HWTEST_F(CellularDataHandlerTest, Telephony_ConnectIfNeed, Function | MediumTest | Level1) 1048 { 1049 EventFwk::MatchingSkills matchingSkills; 1050 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 1051 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 1052 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 1053 cellularDataHandler->Init(); 1054 1055 NetRequest request1; 1056 request1.capability = NetManagerStandard::NET_CAPABILITY_INTERNET; 1057 request1.registerType = REQUEST; 1058 EXPECT_TRUE(cellularDataHandler->RequestNet(request1)); 1059 auto event1 = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_REQUEST_NETWORK, TYPE_REQUEST_NET); 1060 auto apnHolder = 1061 cellularDataHandler->apnManager_->FindApnHolderById(ApnManager::FindApnIdByCapability(request1.capability)); 1062 cellularDataHandler->ConnectIfNeed(event1, apnHolder, request1); 1063 auto event2 = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_REQUEST_NETWORK, TYPE_RELEASE_NET); 1064 cellularDataHandler->ConnectIfNeed(event2, apnHolder, request1); 1065 cellularDataHandler->ConnectIfNeed(event2, nullptr, request1); 1066 } 1067 1068 HWTEST_F(CellularDataHandlerTest, Telephony_CellularDataHandler_003, Function | MediumTest | Level1) 1069 { 1070 CellularDataController controller {0}; 1071 controller.Init(); 1072 ApnActivateReportInfo info1; 1073 ApnActivateReportInfo info2; 1074 EXPECT_TRUE(controller.GetDefaultActReportInfo(info1)); 1075 EXPECT_TRUE(controller.GetInternalActReportInfo(info2)); 1076 controller.cellularDataHandler_ = nullptr; 1077 EXPECT_FALSE(controller.GetDefaultActReportInfo(info1)); 1078 EXPECT_FALSE(controller.GetInternalActReportInfo(info2)); 1079 } 1080 1081 HWTEST_F(CellularDataHandlerTest, DataConnCompleteUpdateStateTest001, Function | MediumTest | Level1) 1082 { 1083 int32_t slotId = 0; 1084 EventFwk::MatchingSkills matchingSkills; 1085 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 1086 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 1087 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, slotId); 1088 std::string apnType = DATA_CONTEXT_ROLE_MMS; 1089 sptr<ApnHolder> apnHolder = new ApnHolder(apnType, slotId); 1090 apnHolder->cellularDataStateMachine_ = nullptr; 1091 auto resultInfo = std::make_shared<SetupDataCallResultInfo>(); 1092 cellularDataHandler->connectionManager_ = nullptr; 1093 cellularDataHandler->physicalConnectionActiveState_ = true; 1094 cellularDataHandler->incallDataStateMachine_ = nullptr; 1095 cellularDataHandler->DataConnCompleteUpdateState(apnHolder, resultInfo); 1096 EXPECT_FALSE(cellularDataHandler->isRilApnAttached_); 1097 1098 sptr<DataConnectionManager> cdConnectionManager = nullptr; 1099 std::shared_ptr<TelEventHandler> telEventHandler = nullptr; 1100 apnHolder->cellularDataStateMachine_ = std::make_shared<CellularDataStateMachine> 1101 (cdConnectionManager, std::move(telEventHandler)); 1102 apnHolder->cellularDataStateMachine_->netLinkInfo_ = new NetLinkInfo(); 1103 apnHolder->cellularDataStateMachine_->netSupplierInfo_ = nullptr; 1104 cellularDataHandler->apnManager_ = std::make_unique<ApnManager>().release(); 1105 cellularDataHandler->apnManager_->allApnItem_.clear(); 1106 cellularDataHandler->connectionManager_ = std::make_unique<DataConnectionManager>(slotId).release(); 1107 cellularDataHandler->physicalConnectionActiveState_ = false; 1108 cellularDataHandler->incallDataStateMachine_ = 1109 cellularDataHandler->CreateIncallDataStateMachine(TelCallStatus::CALL_STATUS_DIALING); 1110 apnHolder->apnType_ = DATA_CONTEXT_ROLE_DEFAULT; 1111 apnHolder->apnItem_ = new ApnItem(); 1112 cellularDataHandler->DataConnCompleteUpdateState(apnHolder, resultInfo); 1113 1114 cellularDataHandler->apnManager_->preferId_ = 1; 1115 cellularDataHandler->apnManager_->allApnItem_.push_back(new ApnItem()); 1116 cellularDataHandler->DataConnCompleteUpdateState(apnHolder, resultInfo); 1117 EXPECT_FALSE(cellularDataHandler->isRilApnAttached_); 1118 } 1119 1120 /** 1121 @tc.number Telephony_CreateApnItem 1122 @tc.name CreateApnItem 1123 @tc.desc Function test 1124 */ 1125 HWTEST_F(CellularDataHandlerTest, CreateApnItemTest001, Function | MediumTest | Level1) 1126 { 1127 int32_t slotId = 0; 1128 EventFwk::MatchingSkills matchingSkills; 1129 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 1130 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, slotId); 1131 cellularDataHandler->apnManager_ = nullptr; 1132 cellularDataHandler->CreateApnItem(); 1133 1134 cellularDataHandler->Init(); 1135 EXPECT_FALSE(cellularDataHandler->apnManager_ == nullptr); 1136 cellularDataHandler->CreateApnItem(); 1137 cellularDataHandler->SendEvent(CellularDataEventCode::MSG_RETRY_TO_CREATE_APN, 0, RETRY_DELAY_TIME); 1138 cellularDataHandler->CreateApnItem(); 1139 EXPECT_TRUE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_CREATE_APN)); 1140 } 1141 1142 /** 1143 @tc.number Telephony_IsCellularDataEnabled 1144 @tc.name IsCellularDataEnabled 1145 @tc.desc Function test 1146 */ 1147 HWTEST_F(CellularDataHandlerTest, IsCellularDataEnabledTest001, Function | MediumTest | Level1) 1148 { 1149 int32_t slotId = 0; 1150 EventFwk::MatchingSkills matchingSkills; 1151 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 1152 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, slotId); 1153 bool isDataEnabled = false; 1154 EXPECT_NE(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS); 1155 1156 cellularDataHandler->Init(); 1157 cellularDataHandler->dataSwitchSettings_->lastQryRet_ = -1; 1158 EXPECT_NE(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS); 1159 cellularDataHandler->dataSwitchSettings_->lastQryRet_ = TELEPHONY_ERR_SUCCESS; 1160 EXPECT_EQ(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS); 1161 } 1162 } // namespace Telephony 1163 } // namespace OHOS