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 "common_event_manager.h" 19 #include "common_event_support.h" 20 #include "cellular_data_constant.h" 21 #include "cellular_data_handler.h" 22 #include "core_manager_inner.h" 23 #include "mock/mock_sim_manager.h" 24 #include "mock/mock_network_search.h" 25 26 namespace OHOS { 27 namespace Telephony { 28 using namespace testing::ext; 29 using ::testing::_; 30 using ::testing::AtLeast; 31 using ::testing::Return; 32 using ::testing::DoAll; 33 using ::testing::SetArgReferee; 34 35 class CellularDataHandlerBranchTest : public testing::Test { 36 public: 37 CellularDataHandlerBranchTest() = default; 38 ~CellularDataHandlerBranchTest() = default; TearDownTestCase()39 static void TearDownTestCase() 40 { 41 UnmockManager(); 42 } 43 InitMockManager()44 void InitMockManager() 45 { 46 mockSimManager = new MockSimManager(); 47 std::shared_ptr<MockSimManager> mockSimManagerPtr(mockSimManager); 48 CoreManagerInner::GetInstance().simManager_ = mockSimManagerPtr; 49 50 mockNetworkSearchManager = new MockNetworkSearchManager(); 51 std::shared_ptr<MockNetworkSearchManager> mockNetworkSearchManagerPtr(mockNetworkSearchManager); 52 CoreManagerInner::GetInstance().networkSearchManager_ = mockNetworkSearchManagerPtr; 53 } 54 UnmockManager()55 static void UnmockManager() 56 { 57 if (CoreManagerInner::GetInstance().simManager_ != nullptr) { 58 CoreManagerInner::GetInstance().simManager_ = nullptr; 59 std::cout << "CellularDataHandlerBranchTest set simManager_ nullptr" << std::endl; 60 } 61 if (CoreManagerInner::GetInstance().networkSearchManager_ != nullptr) { 62 CoreManagerInner::GetInstance().networkSearchManager_ = nullptr; 63 std::cout << "CellularDataHandlerBranchTest set networkSearchManager_ nullptr" << std::endl; 64 } 65 } 66 InitCellularDataHandler()67 void InitCellularDataHandler() 68 { 69 EventFwk::MatchingSkills matchingSkills; 70 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 71 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 72 cellularDataHandler_ = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 73 cellularDataHandler_->Init(); 74 } 75 76 std::shared_ptr<CellularDataHandler> cellularDataHandler_; 77 MockSimManager *mockSimManager; 78 MockNetworkSearchManager *mockNetworkSearchManager; 79 }; 80 81 HWTEST_F(CellularDataHandlerBranchTest, RoamingStateOn_001, Function | MediumTest | Level3) 82 { 83 InitCellularDataHandler(); 84 InitMockManager(); 85 // GetPsRoamingState return 1, dataRoamingEnabled is false 86 EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1)); 87 EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(0)); 88 auto event = AppExecFwk::InnerEvent::Get(0); 89 cellularDataHandler_->RoamingStateOn(event); 90 91 // GetPsRoamingState return 1, dataRoamingEnabled is false 92 EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1)); 93 EXPECT_CALL(*mockSimManager, GetSimId(_)).Times(AtLeast(0)).WillRepeatedly(Return(1)); 94 cellularDataHandler_->defaultDataRoamingEnable_ = true; 95 auto event1 = AppExecFwk::InnerEvent::Get(0); 96 cellularDataHandler_->RoamingStateOn(event1); 97 EXPECT_EQ(cellularDataHandler_->apnManager_->GetOverallApnState(), PROFILE_STATE_IDLE); 98 UnmockManager(); 99 } 100 101 HWTEST_F(CellularDataHandlerBranchTest, CheckRoamingState_001, Function | MediumTest | Level3) 102 { 103 InitCellularDataHandler(); 104 InitMockManager(); 105 // roamingState true, dataRoamingEnabled true, isMmsApn true, isEmergencyApn false, IsRestrictedMode false 106 EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1)); 107 EXPECT_CALL(*mockNetworkSearchManager, GetPsRadioTech(_, _)).WillOnce(Return(0)); 108 sptr<ApnHolder> apnHolder = new ApnHolder("mms", 0); 109 ASSERT_FALSE(cellularDataHandler_ == nullptr); 110 ASSERT_FALSE(cellularDataHandler_->dataSwitchSettings_ == nullptr); 111 cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(true); 112 ASSERT_TRUE(cellularDataHandler_->CheckRoamingState(apnHolder)); 113 114 // roamingState false, dataRoamingEnabled true, isMmsApn false, isEmergencyApn true, IsRestrictedMode false 115 EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(0)); 116 EXPECT_CALL(*mockNetworkSearchManager, GetPsRadioTech(_, _)).WillOnce(Return(0)); 117 apnHolder = new ApnHolder("emergency", 0); 118 cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(true); 119 ASSERT_TRUE(cellularDataHandler_->CheckRoamingState(apnHolder)); 120 121 // roamingState true, dataRoamingEnabled false, isMmsApn true, isEmergencyApn false, IsRestrictedMode false 122 EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(1)); 123 apnHolder = new ApnHolder("mms", 0); 124 cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(false); 125 ASSERT_FALSE(cellularDataHandler_->CheckRoamingState(apnHolder)); 126 127 // roamingState false, dataRoamingEnabled false, isMmsApn false, isEmergencyApn true, IsRestrictedMode true 128 int32_t tech = 1; 129 EXPECT_CALL(*mockNetworkSearchManager, GetPsRoamingState(_)).WillOnce(Return(0)); 130 EXPECT_CALL(*mockNetworkSearchManager, GetPsRadioTech(_, _)).WillOnce(DoAll(SetArgReferee<1>(tech), Return(0))); 131 cellularDataHandler_->lastCallState_ = 1; 132 apnHolder = new ApnHolder("emergency", 0); 133 cellularDataHandler_->dataSwitchSettings_->UpdateUserDataRoamingOn(false); 134 ASSERT_FALSE(cellularDataHandler_->CheckRoamingState(apnHolder)); 135 UnmockManager(); 136 } 137 138 HWTEST_F(CellularDataHandlerBranchTest, IsCellularDataRoamingEnabled_001, Function | MediumTest | Level3) 139 { 140 EventFwk::MatchingSkills matchingSkills; 141 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 142 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 143 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 144 145 EXPECT_EQ(cellularDataHandler->dataSwitchSettings_, nullptr); 146 cellularDataHandler->defaultDataRoamingEnable_ = false; 147 bool result = false; 148 cellularDataHandler->IsCellularDataRoamingEnabled(result); 149 ASSERT_FALSE(result); 150 151 cellularDataHandler->Init(); 152 cellularDataHandler->IsCellularDataRoamingEnabled(result); 153 ASSERT_TRUE(result); 154 } 155 156 HWTEST_F(CellularDataHandlerBranchTest, SetDataPermittedForMms_001, Function | MediumTest | Level3) 157 { 158 EventFwk::MatchingSkills matchingSkills; 159 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 160 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 161 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 162 163 EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr); 164 cellularDataHandler->incallDataStateMachine_ = 165 cellularDataHandler->CreateIncallDataStateMachine(CALL_STATUS_DIALING); 166 ASSERT_FALSE(cellularDataHandler->SetDataPermittedForMms(false)); 167 } 168 169 HWTEST_F(CellularDataHandlerBranchTest, CheckApnState_001, Function | MediumTest | Level3) 170 { 171 EventFwk::MatchingSkills matchingSkills; 172 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 173 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 174 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 175 cellularDataHandler->Init(); 176 177 sptr<ApnHolder> apnHolder = new ApnHolder("mms", 0); 178 apnHolder->SetApnState(PROFILE_STATE_DISCONNECTING); 179 ASSERT_FALSE(cellularDataHandler->CheckApnState(apnHolder)); 180 181 apnHolder->SetApnState(PROFILE_STATE_FAILED); 182 ASSERT_FALSE(cellularDataHandler->CheckApnState(apnHolder)); 183 184 apnHolder->SetApnState(PROFILE_STATE_CONNECTING); 185 ASSERT_FALSE(cellularDataHandler->CheckApnState(apnHolder)); 186 } 187 188 HWTEST_F(CellularDataHandlerBranchTest, EstablishDataConnection_001, Function | MediumTest | Level3) 189 { 190 EventFwk::MatchingSkills matchingSkills; 191 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 192 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 193 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 194 cellularDataHandler->Init(); 195 196 sptr<ApnHolder> apnHolder = new ApnHolder("mms", 0); 197 ApnItem apnItem; 198 sptr<ApnItem> item = apnItem.MakeDefaultApn("mms"); 199 std::vector<sptr<ApnItem>> matchedApns; 200 matchedApns.push_back(item); 201 apnHolder->SetAllMatchedApns(matchedApns); 202 cellularDataHandler->EstablishDataConnection(apnHolder, 1); 203 ASSERT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTING); 204 } 205 206 HWTEST_F(CellularDataHandlerBranchTest, DisconnectDataComplete_001, Function | MediumTest | Level3) 207 { 208 EventFwk::MatchingSkills matchingSkills; 209 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 210 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 211 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 212 cellularDataHandler->Init(); 213 214 auto event = AppExecFwk::InnerEvent::Get(0); 215 cellularDataHandler->DisconnectDataComplete(event); 216 ASSERT_EQ(event->GetSharedObject<SetupDataCallResultInfo>(), nullptr); 217 } 218 219 HWTEST_F(CellularDataHandlerBranchTest, DisconnectDataComplete_002, Function | MediumTest | Level3) 220 { 221 EventFwk::MatchingSkills matchingSkills; 222 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 223 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 224 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 225 cellularDataHandler->Init(); 226 227 std::shared_ptr<SetupDataCallResultInfo> resultInfo = std::make_shared<SetupDataCallResultInfo>(); 228 resultInfo->flag = 2; 229 auto event = AppExecFwk::InnerEvent::Get(0, resultInfo); 230 sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->FindApnHolderById(2); 231 sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(0).release(); 232 if (connectionManager == nullptr) { 233 return; 234 } 235 connectionManager->Init(); 236 std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine = 237 std::make_shared<CellularDataStateMachine>(connectionManager, cellularDataHandler); 238 apnHolder->SetCellularDataStateMachine(cellularDataStateMachine); 239 cellularDataHandler->DisconnectDataComplete(event); 240 ASSERT_EQ(event->GetSharedObject<SetupDataCallResultInfo>(), resultInfo); 241 } 242 243 HWTEST_F(CellularDataHandlerBranchTest, UpdatePhysicalConnectionState_001, Function | MediumTest | Level3) 244 { 245 EventFwk::MatchingSkills matchingSkills; 246 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 247 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 248 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 249 cellularDataHandler->Init(); 250 251 cellularDataHandler->physicalConnectionActiveState_ = true; 252 cellularDataHandler->UpdatePhysicalConnectionState(true); 253 ASSERT_FALSE(cellularDataHandler->physicalConnectionActiveState_); 254 255 cellularDataHandler->physicalConnectionActiveState_ = false; 256 cellularDataHandler->UpdatePhysicalConnectionState(true); 257 ASSERT_FALSE(cellularDataHandler->physicalConnectionActiveState_); 258 259 cellularDataHandler->physicalConnectionActiveState_ = true; 260 cellularDataHandler->UpdatePhysicalConnectionState(false); 261 ASSERT_TRUE(cellularDataHandler->physicalConnectionActiveState_); 262 263 cellularDataHandler->physicalConnectionActiveState_ = false; 264 cellularDataHandler->UpdatePhysicalConnectionState(false); 265 ASSERT_TRUE(cellularDataHandler->physicalConnectionActiveState_); 266 } 267 268 HWTEST_F(CellularDataHandlerBranchTest, OnReceiveEvent_001, Function | MediumTest | Level3) 269 { 270 EventFwk::MatchingSkills matchingSkills; 271 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 272 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 273 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); 274 cellularDataHandler->Init(); 275 276 auto want = EventFwk::Want(); 277 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 278 auto event = EventFwk::CommonEventData(want); 279 cellularDataHandler->OnReceiveEvent(event); 280 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 281 282 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED); 283 event = EventFwk::CommonEventData(want); 284 cellularDataHandler->OnReceiveEvent(event); 285 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED); 286 287 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED); 288 event = EventFwk::CommonEventData(want); 289 cellularDataHandler->OnReceiveEvent(event); 290 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED); 291 292 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON); 293 event = EventFwk::CommonEventData(want); 294 cellularDataHandler->OnReceiveEvent(event); 295 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON); 296 297 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF); 298 event = EventFwk::CommonEventData(want); 299 cellularDataHandler->OnReceiveEvent(event); 300 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF); 301 302 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); 303 event = EventFwk::CommonEventData(want); 304 cellularDataHandler->OnReceiveEvent(event); 305 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); 306 } 307 308 HWTEST_F(CellularDataHandlerBranchTest, OnReceiveEvent_002, Function | MediumTest | Level3) 309 { 310 EventFwk::MatchingSkills matchingSkills; 311 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 312 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 313 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 314 cellularDataHandler->Init(); 315 316 auto want = EventFwk::Want(); 317 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 318 auto event = EventFwk::CommonEventData(want); 319 cellularDataHandler->OnReceiveEvent(event); 320 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 321 322 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED); 323 event = EventFwk::CommonEventData(want); 324 cellularDataHandler->OnReceiveEvent(event); 325 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED); 326 327 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED); 328 event = EventFwk::CommonEventData(want); 329 cellularDataHandler->OnReceiveEvent(event); 330 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED); 331 332 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON); 333 event = EventFwk::CommonEventData(want); 334 cellularDataHandler->OnReceiveEvent(event); 335 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON); 336 337 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF); 338 event = EventFwk::CommonEventData(want); 339 cellularDataHandler->OnReceiveEvent(event); 340 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF); 341 342 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); 343 event = EventFwk::CommonEventData(want); 344 cellularDataHandler->OnReceiveEvent(event); 345 ASSERT_EQ(want.GetAction(), EventFwk::CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY); 346 } 347 348 HWTEST_F(CellularDataHandlerBranchTest, HandleScreenStateChanged_001, Function | MediumTest | Level3) 349 { 350 EventFwk::MatchingSkills matchingSkills; 351 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 352 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 353 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 354 cellularDataHandler->HandleScreenStateChanged(true); 355 ASSERT_EQ(cellularDataHandler->connectionManager_, nullptr); 356 cellularDataHandler->Init(); 357 cellularDataHandler->HandleScreenStateChanged(true); 358 ASSERT_NE(cellularDataHandler->connectionManager_, nullptr); 359 } 360 361 HWTEST_F(CellularDataHandlerBranchTest, UpdateCellularDataConnectState_001, Function | MediumTest | Level3) 362 { 363 EventFwk::MatchingSkills matchingSkills; 364 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 365 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 366 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 367 cellularDataHandler->Init(); 368 369 cellularDataHandler->UpdateCellularDataConnectState("default"); 370 ASSERT_NE(cellularDataHandler->apnManager_, nullptr); 371 372 cellularDataHandler->UpdateCellularDataConnectState("internal_default"); 373 ASSERT_NE(cellularDataHandler->apnManager_, nullptr); 374 375 cellularDataHandler->UpdateCellularDataConnectState("mss"); 376 ASSERT_NE(cellularDataHandler->apnManager_, nullptr); 377 } 378 379 HWTEST_F(CellularDataHandlerBranchTest, HandleDBSettingIncallChanged_001, Function | MediumTest | Level3) 380 { 381 EventFwk::MatchingSkills matchingSkills; 382 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 383 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 384 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 385 cellularDataHandler->Init(); 386 cellularDataHandler->HandleImsCallChanged(TelCallStatus::CALL_STATUS_DIALING); 387 388 auto event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(DataSwitchCode::CELLULAR_DATA_ENABLED)); 389 cellularDataHandler->HandleDBSettingIncallChanged(event); 390 ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr); 391 392 event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(DataSwitchCode::CELLULAR_DATA_DISABLED)); 393 cellularDataHandler->HandleDBSettingIncallChanged(event); 394 ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr); 395 396 cellularDataHandler->IncallDataComplete(event); 397 ASSERT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr); 398 } 399 400 HWTEST_F(CellularDataHandlerBranchTest, HandleImsCallChanged, Function | MediumTest | Level3) 401 { 402 EventFwk::MatchingSkills matchingSkills; 403 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 404 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 405 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 406 cellularDataHandler->Init(); 407 408 ASSERT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr); 409 cellularDataHandler->HandleImsCallChanged(TelCallStatus::CALL_STATUS_DIALING); 410 cellularDataHandler->HandleImsCallChanged(TelCallStatus::CALL_STATUS_INCOMING); 411 ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr); 412 cellularDataHandler->HandleVoiceCallChanged(TelCallStatus::CALL_STATUS_DISCONNECTED); 413 cellularDataHandler->HandleVoiceCallChanged(TelCallStatus::CALL_STATUS_IDLE); 414 ASSERT_NE(cellularDataHandler->incallDataStateMachine_, nullptr); 415 } 416 417 HWTEST_F(CellularDataHandlerBranchTest, ReleaseAllNetworkRequest, Function | MediumTest | Level3) 418 { 419 EventFwk::MatchingSkills matchingSkills; 420 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 421 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 422 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 423 cellularDataHandler->Init(); 424 cellularDataHandler->ReleaseAllNetworkRequest(); 425 ASSERT_NE(cellularDataHandler->apnManager_, nullptr); 426 } 427 428 HWTEST_F(CellularDataHandlerBranchTest, HandleSimStateChanged, Function | MediumTest | Level3) 429 { 430 InitCellularDataHandler(); 431 InitMockManager(); 432 433 SimState simState = SimState::SIM_STATE_READY; 434 std::u16string iccId = u"iccId"; 435 EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0))); 436 EXPECT_CALL(*mockSimManager, GetSimIccId(_, _)).WillOnce(DoAll(SetArgReferee<1>(iccId), Return(0))); 437 cellularDataHandler_->HandleSimStateChanged(); 438 ASSERT_NE(cellularDataHandler_->lastIccId_, iccId); 439 440 cellularDataHandler_->lastIccId_ = u"iccId"; 441 EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0))); 442 EXPECT_CALL(*mockSimManager, GetSimIccId(_, _)).WillOnce(DoAll(SetArgReferee<1>(iccId), Return(0))); 443 cellularDataHandler_->HandleSimStateChanged(); 444 ASSERT_EQ(cellularDataHandler_->lastIccId_, iccId); 445 446 cellularDataHandler_->isRilApnAttached_ = true; 447 simState = SimState::SIM_STATE_NOT_PRESENT; 448 EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0))); 449 cellularDataHandler_->HandleSimStateChanged(); 450 451 simState = SimState::SIM_STATE_NOT_READY; 452 EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillOnce(DoAll(SetArgReferee<1>(simState), Return(0))); 453 cellularDataHandler_->HandleSimStateChanged(); 454 ASSERT_FALSE(cellularDataHandler_->isRilApnAttached_); 455 456 UnmockManager(); 457 } 458 459 HWTEST_F(CellularDataHandlerBranchTest, HandleRecordsChanged, Function | MediumTest | Level3) 460 { 461 InitCellularDataHandler(); 462 InitMockManager(); 463 464 cellularDataHandler_->lastIccId_ = u""; 465 std::u16string iccId = u"iccId"; 466 EXPECT_CALL(*mockSimManager, GetSimIccId(_, _)).WillOnce(DoAll(SetArgReferee<1>(iccId), Return(0))); 467 EXPECT_CALL(*mockSimManager, GetOperatorConfigs(_, _)).Times(AtLeast(0)); 468 EXPECT_CALL(*mockSimManager, GetSimId(_)).Times(AtLeast(0)); 469 EXPECT_CALL(*mockSimManager, GetSimOperatorNumeric(_, _)).Times(AtLeast(0)); 470 EXPECT_CALL(*mockSimManager, IsCTSimCard(_, _)).Times(AtLeast(0)); 471 EXPECT_CALL(*mockSimManager, GetDefaultCellularDataSlotId()).WillOnce(Return(0)); 472 cellularDataHandler_->HandleSimAccountLoaded(); 473 cellularDataHandler_->HandleRecordsChanged(); 474 ASSERT_EQ(cellularDataHandler_->lastIccId_, iccId); 475 476 UnmockManager(); 477 } 478 479 HWTEST_F(CellularDataHandlerBranchTest, SetPolicyDataOn, Function | MediumTest | Level3) 480 { 481 EventFwk::MatchingSkills matchingSkills; 482 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 483 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 484 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 485 cellularDataHandler->Init(); 486 487 cellularDataHandler->dataSwitchSettings_->SetPolicyDataOn(true); 488 cellularDataHandler->SetPolicyDataOn(false); 489 ASSERT_FALSE(cellularDataHandler->dataSwitchSettings_->IsPolicyDataOn()); 490 491 cellularDataHandler->SetPolicyDataOn(true); 492 ASSERT_TRUE(cellularDataHandler->dataSwitchSettings_->IsPolicyDataOn()); 493 } 494 495 HWTEST_F(CellularDataHandlerBranchTest, ChangeConnectionForDsds, Function | MediumTest | Level3) 496 { 497 EventFwk::MatchingSkills matchingSkills; 498 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 499 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 500 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 501 cellularDataHandler->Init(); 502 503 cellularDataHandler->ChangeConnectionForDsds(false); 504 ASSERT_TRUE(cellularDataHandler->ChangeConnectionForDsds(false)); 505 ASSERT_TRUE(cellularDataHandler->ChangeConnectionForDsds(true)); 506 } 507 508 HWTEST_F(CellularDataHandlerBranchTest, HandleDBSettingRoamingChanged, Function | MediumTest | Level3) 509 { 510 EventFwk::MatchingSkills matchingSkills; 511 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 512 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 513 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 514 cellularDataHandler->Init(); 515 516 auto event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED)); 517 cellularDataHandler->HandleDBSettingRoamingChanged(event); 518 519 event = AppExecFwk::InnerEvent::Get(0, static_cast<int64_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED)); 520 cellularDataHandler->HandleDBSettingRoamingChanged(event); 521 ASSERT_EQ(event->GetParam(), 0); 522 } 523 524 HWTEST_F(CellularDataHandlerBranchTest, UnRegisterDataSettingObserver, Function | MediumTest | Level3) 525 { 526 InitCellularDataHandler(); 527 InitMockManager(); 528 529 EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1)); 530 cellularDataHandler_->UnRegisterDataSettingObserver(); 531 EXPECT_CALL(*mockSimManager, GetSimId(_)).WillOnce(Return(1)); 532 cellularDataHandler_->RegisterDataSettingObserver(); 533 ASSERT_NE(cellularDataHandler_->settingObserver_, nullptr); 534 ASSERT_NE(cellularDataHandler_->roamingObserver_, nullptr); 535 ASSERT_NE(cellularDataHandler_->incallObserver_, nullptr); 536 ASSERT_NE(cellularDataHandler_->cellularDataRdbObserver_, nullptr); 537 538 UnmockManager(); 539 } 540 541 HWTEST_F(CellularDataHandlerBranchTest, CheckForCompatibleDataConnection, Function | MediumTest | Level3) 542 { 543 EventFwk::MatchingSkills matchingSkills; 544 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 545 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 546 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 547 cellularDataHandler->Init(); 548 549 sptr<ApnHolder> apnHolder = new ApnHolder("dun", 0); 550 cellularDataHandler->CheckForCompatibleDataConnection(apnHolder); 551 ASSERT_EQ(apnHolder->GetApnType(), DATA_CONTEXT_ROLE_DUN); 552 } 553 554 HWTEST_F(CellularDataHandlerBranchTest, ReleaseCellularDataConnection, Function | MediumTest | Level3) 555 { 556 EventFwk::MatchingSkills matchingSkills; 557 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 558 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 559 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); 560 561 cellularDataHandler->ReleaseCellularDataConnection(); 562 ASSERT_EQ(cellularDataHandler->apnManager_, nullptr); 563 cellularDataHandler->Init(); 564 cellularDataHandler->ReleaseCellularDataConnection(); 565 ASSERT_NE(cellularDataHandler->apnManager_, nullptr); 566 } 567 568 HWTEST_F(CellularDataHandlerBranchTest, CheckCellularDataSlotId, Function | MediumTest | Level3) 569 { 570 EventFwk::MatchingSkills matchingSkills; 571 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); 572 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); 573 574 auto cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 2); // 2: vsim slot id 575 cellularDataHandler->Init(); 576 sptr<ApnHolder> apnHolder = new ApnHolder(DATA_CONTEXT_ROLE_DEFAULT, 0); 577 cellularDataHandler->CheckCellularDataSlotId(apnHolder); 578 579 cellularDataHandler.reset(); 580 cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 0); // 0: sim0 slot id 581 cellularDataHandler->Init(); 582 apnHolder = new ApnHolder(DATA_CONTEXT_ROLE_MMS, 0); 583 cellularDataHandler->CheckCellularDataSlotId(apnHolder); 584 apnHolder->apnType_ = DATA_CONTEXT_ROLE_DEFAULT; 585 bool ret = cellularDataHandler->CheckCellularDataSlotId(apnHolder); 586 EXPECT_FALSE(ret); 587 588 cellularDataHandler.reset(); 589 cellularDataHandler = std::make_shared<CellularDataHandler>(subscriberInfo, 1); // 1: sim1 slot id 590 cellularDataHandler->Init(); 591 apnHolder = new ApnHolder(DATA_CONTEXT_ROLE_MMS, 0); 592 cellularDataHandler->CheckCellularDataSlotId(apnHolder); 593 apnHolder->apnType_ = DATA_CONTEXT_ROLE_DEFAULT; 594 ret = cellularDataHandler->CheckCellularDataSlotId(apnHolder); 595 EXPECT_FALSE(ret); 596 } 597 598 HWTEST_F(CellularDataHandlerBranchTest, ResumeDataPermittedTimerOut_001, Function | MediumTest | Level3) 599 { 600 InitCellularDataHandler(); 601 InitMockManager(); 602 603 auto event = AppExecFwk::InnerEvent::Get(0); 604 auto apnHolder = 605 cellularDataHandler_->apnManager_->FindApnHolderById(DataContextRolesId::DATA_CONTEXT_ROLE_MMS_ID); 606 apnHolder->SetApnState(PROFILE_STATE_IDLE); 607 cellularDataHandler_->ResumeDataPermittedTimerOut(event); 608 EXPECT_TRUE(cellularDataHandler_->dataSwitchSettings_->IsInternalDataOn()); 609 610 cellularDataHandler_->apnManager_ = nullptr; 611 cellularDataHandler_->ResumeDataPermittedTimerOut(event); 612 EXPECT_TRUE(cellularDataHandler_->dataSwitchSettings_->IsInternalDataOn()); 613 } 614 615 HWTEST_F(CellularDataHandlerBranchTest, CheckAttachAndSimState_001, Function | MediumTest | Level3) 616 { 617 InitCellularDataHandler(); 618 InitMockManager(); 619 620 auto apnHolder = 621 cellularDataHandler_->apnManager_->FindApnHolderById(DataContextRolesId::DATA_CONTEXT_ROLE_MMS_ID); 622 SimState simState = SimState::SIM_STATE_READY; 623 EXPECT_CALL(*mockSimManager, GetSimState(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(simState), Return(0))); 624 EXPECT_CALL(*mockNetworkSearchManager, GetPsRegState(_)).WillOnce(Return(0)); 625 EXPECT_FALSE(cellularDataHandler_->CheckAttachAndSimState(apnHolder)); 626 627 cellularDataHandler_->RemoveAllEvents(); 628 EXPECT_CALL(*mockNetworkSearchManager, GetPsRegState(_)).WillOnce(Return(1)); 629 cellularDataHandler_->CheckAttachAndSimState(apnHolder); 630 EXPECT_FALSE(cellularDataHandler_->HasInnerEvent(CellularDataEventCode::MSG_RESUME_DATA_PERMITTED_TIMEOUT)); 631 } 632 } // namespace Telephony 633 } // namespace OHOS