From b100b7351830a870afa5207f8b957dedcb4b5a71 Mon Sep 17 00:00:00 2001 From: l00635678 Date: Tue, 6 Aug 2024 14:37:05 +0800 Subject: [PATCH] =?UTF-8?q?IPV4V6=E7=B1=BB=E5=9E=8B=E7=9A=84=E5=8D=A12?= =?UTF-8?q?=E5=81=9A=E6=95=B0=E6=8D=AE=E4=B8=9A=E5=8A=A1=E4=B8=BB=E5=8D=A1?= =?UTF-8?q?=E6=97=B6MTU=E4=B8=8D=E5=AF=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- services/include/cellular_data_handler.h | 3 + services/include/state_machine/default.h | 3 - services/src/cellular_data_handler.cpp | 31 ++++ .../cellular_data_state_machine.cpp | 5 +- services/src/state_machine/default.cpp | 23 --- test/BUILD.gn | 1 + test/cellular_data_handler_test.cpp | 162 ++++++++++++++++++ test/cellular_state_machine_test.cpp | 83 --------- .../updatedisconnectmachine_fuzzer.cpp | 1 - test/zero_branch_test.cpp | 3 +- 10 files changed, 202 insertions(+), 113 deletions(-) create mode 100644 test/cellular_data_handler_test.cpp diff --git a/services/include/cellular_data_handler.h b/services/include/cellular_data_handler.h index 33182d17..d5af02b0 100644 --- a/services/include/cellular_data_handler.h +++ b/services/include/cellular_data_handler.h @@ -74,6 +74,7 @@ public: void RegisterDataSettingObserver(); void UnRegisterDataSettingObserver(); int32_t GetIntelligenceSwitchState(bool &switchState); + void HandleUpdateNetInfo(const AppExecFwk::InnerEvent::Pointer &event); private: std::shared_ptr CreateCellularDataConnect(); @@ -231,6 +232,8 @@ private: [this](const AppExecFwk::InnerEvent::Pointer &event) { HandleFactoryReset(event); } }, { RadioEvent::RADIO_CLEAN_ALL_DATA_CONNECTIONS, [this](const AppExecFwk::InnerEvent::Pointer &event) { OnCleanAllDataConnectionsDone(event); } }, + { CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, + [this](const AppExecFwk::InnerEvent::Pointer &event) { HandleUpdateNetInfo(event); } }, }; }; } // namespace Telephony diff --git a/services/include/state_machine/default.h b/services/include/state_machine/default.h index 6fc0914c..c9eecf26 100644 --- a/services/include/state_machine/default.h +++ b/services/include/state_machine/default.h @@ -42,7 +42,6 @@ private: bool ProcessDataConnectionDrsOrRatChanged(const AppExecFwk::InnerEvent::Pointer &event); bool ProcessDataConnectionRoamOn(const AppExecFwk::InnerEvent::Pointer &event); bool ProcessDataConnectionRoamOff(const AppExecFwk::InnerEvent::Pointer &event); - bool ProcessDataCallListChanged(const AppExecFwk::InnerEvent::Pointer &event); private: using Fun = std::function; @@ -60,8 +59,6 @@ private: [this](const AppExecFwk::InnerEvent::Pointer &data) { return ProcessDataConnectionRoamOn(data); } }, { CellularDataEventCode::MSG_SM_DATA_ROAM_OFF, [this](const AppExecFwk::InnerEvent::Pointer &data) { return ProcessDataConnectionRoamOff(data); } }, - { CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, - [this](const AppExecFwk::InnerEvent::Pointer &data) { return ProcessDataCallListChanged(data); } }, }; std::weak_ptr stateMachine_; }; diff --git a/services/src/cellular_data_handler.cpp b/services/src/cellular_data_handler.cpp index b493cb39..e0a84b10 100644 --- a/services/src/cellular_data_handler.cpp +++ b/services/src/cellular_data_handler.cpp @@ -2118,6 +2118,37 @@ std::shared_ptr CellularDataHandler::CheckForCompatibl return potentialDc; } +void CellularDataHandler::HandleUpdateNetInfo(const AppExecFwk::InnerEvent::Pointer &event) +{ + TELEPHONY_LOGI("Slot%{public}d: HandleUpdateNetInfo", slotId_); + if (event == nullptr || connectionManager_ == nullptr || apnManager_ == nullptr) { + TELEPHONY_LOGE("event or connectionManager_ or apnManager_ is null"); + return; + } + + std::shared_ptr info = event->GetSharedObject(); + if (info == nullptr) { + TELEPHONY_LOGE("info is null"); + return; + } + + sptr apnHolder = apnManager_->GetApnHolder(apnManager_->FindApnNameByApnId(info->flag)); + if (apnHolder == nullptr) { + TELEPHONY_LOGE("Slot%{public}d: flag:%{public}d complete apnHolder is null", slotId_, info->flag); + return; + } + if (apnHolder->GetApnState() != PROFILE_STATE_CONNECTING && apnHolder->GetApnState() != PROFILE_STATE_CONNECTED) { + TELEPHONY_LOGE("Slot%{public}d: apnHolder is not connecting or connected", slotId_); + return; + } + std::shared_ptr stateMachine = connectionManager_->GetActiveConnectionByCid(info->cid); + if (stateMachine == nullptr) { + TELEPHONY_LOGE("stateMachine is null"); + return; + } + stateMachine->UpdateNetworkInfo(*info); +} + bool CellularDataHandler::IsGsm() { bool isGsm = false; diff --git a/services/src/state_machine/cellular_data_state_machine.cpp b/services/src/state_machine/cellular_data_state_machine.cpp index 1fe14e06..4c6474b3 100644 --- a/services/src/state_machine/cellular_data_state_machine.cpp +++ b/services/src/state_machine/cellular_data_state_machine.cpp @@ -433,12 +433,13 @@ void CellularDataStateMachine::SetConnectionTcpBuffer(const std::string &tcpBuff void CellularDataStateMachine::UpdateNetworkInfoIfInActive(SetupDataCallResultInfo &info) { - if (stateMachineEventHandler_ == nullptr) { + if (cellularDataHandler_ == nullptr) { TELEPHONY_LOGE("stateMachineEventHandler_ is nullptr"); return; } auto netInfo = std::make_shared(info); - stateMachineEventHandler_->SendEvent(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); + netInfo->flag = apnId_; + cellularDataHandler_->SendEvent(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); } } // namespace Telephony } // namespace OHOS diff --git a/services/src/state_machine/default.cpp b/services/src/state_machine/default.cpp index 83a1a5bd..96e49527 100644 --- a/services/src/state_machine/default.cpp +++ b/services/src/state_machine/default.cpp @@ -127,28 +127,5 @@ bool Default::ProcessDataConnectionRoamOff(const AppExecFwk::InnerEvent::Pointer TELEPHONY_LOGI("Default::EVENT_DATA_CONNECTION_ROAM_OFF"); return false; } - -bool Default::ProcessDataCallListChanged(const AppExecFwk::InnerEvent::Pointer &event) -{ - if (event == nullptr) { - TELEPHONY_LOGE("event is null"); - return false; - } - std::shared_ptr info = event->GetSharedObject(); - if (info == nullptr) { - TELEPHONY_LOGE("info is null"); - return false; - } - TELEPHONY_LOGI("Default::ProcessDataCallListChanged"); - std::shared_ptr stateMachine = stateMachine_.lock(); - if (stateMachine == nullptr) { - TELEPHONY_LOGE("stateMachine is null"); - return false; - } - if (stateMachine->IsActivatingState() || stateMachine->IsActiveState()) { - stateMachine->UpdateNetworkInfo(*info); - } - return true; -} } // namespace Telephony } // namespace OHOS diff --git a/test/BUILD.gn b/test/BUILD.gn index 06dbcfbf..53388fe9 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -21,6 +21,7 @@ ohos_unittest("tel_cellular_data_test") { sources = [ "$SOURCE_DIR/test/apn_manager_test.cpp", + "$SOURCE_DIR/test/cellular_data_handler_test.cpp", "$SOURCE_DIR/test/cellular_data_test.cpp", "$SOURCE_DIR/test/data_access_token.cpp", "$SOURCE_DIR/test/zero_branch_test.cpp", diff --git a/test/cellular_data_handler_test.cpp b/test/cellular_data_handler_test.cpp new file mode 100644 index 00000000..bd9384fa --- /dev/null +++ b/test/cellular_data_handler_test.cpp @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#define private public +#define protected public + +#include "gtest/gtest.h" +#include "common_event_manager.h" +#include "common_event_support.h" +#include "cellular_data_handler.h" + +namespace OHOS { +namespace Telephony { +using namespace testing::ext; + +class CellularDataHandlerTest : public testing::Test { +public: + static void SetUpTestCase() {} + static void TearDownTestCase() {} + void SetUp() {} + void TearDown() {} +}; + +/** + * @tc.number HandleUpdateNetInfo_001 + * @tc.name test error branch + * @tc.desc Function test + */ +HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_001, Function | MediumTest | Level3) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = std::make_shared(subscriberInfo, 0); + auto netInfo = std::make_shared(); + auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); + cellularDataHandler->HandleUpdateNetInfo(event); + EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr); + EXPECT_EQ(cellularDataHandler->apnManager_, nullptr); +} + +/** + * @tc.number HandleUpdateNetInfo_002 + * @tc.name test error branch + * @tc.desc Function test + */ +HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_002, Function | MediumTest | Level3) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = std::make_shared(subscriberInfo, 0); + cellularDataHandler->Init(); + auto netInfo = std::make_shared(); + auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED); + cellularDataHandler->HandleUpdateNetInfo(event); + EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); + EXPECT_NE(cellularDataHandler->apnManager_, nullptr); + EXPECT_EQ(event->GetSharedObject(), nullptr); +} + +/** + * @tc.number HandleUpdateNetInfo_003 + * @tc.name test error branch + * @tc.desc Function test + */ +HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_003, Function | MediumTest | Level3) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = std::make_shared(subscriberInfo, 0); + cellularDataHandler->Init(); + auto netInfo = std::make_shared(); + netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID; + auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); + cellularDataHandler->HandleUpdateNetInfo(event); + EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); + EXPECT_NE(cellularDataHandler->apnManager_, nullptr); + EXPECT_NE(event->GetSharedObject(), nullptr); + sptr apnHolder = cellularDataHandler->apnManager_->GetApnHolder( + cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag)); + EXPECT_NE(apnHolder, nullptr); + EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_IDLE); +} + +/** + * @tc.number HandleUpdateNetInfo_004 + * @tc.name test error branch + * @tc.desc Function test + */ +HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_004, Function | MediumTest | Level3) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = std::make_shared(subscriberInfo, 0); + cellularDataHandler->Init(); + auto netInfo = std::make_shared(); + netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID; + sptr apnHolder = cellularDataHandler->apnManager_->GetApnHolder( + cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag)); + EXPECT_NE(apnHolder, nullptr); + apnHolder->SetApnState(PROFILE_STATE_CONNECTED); + auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); + cellularDataHandler->HandleUpdateNetInfo(event); + EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); + EXPECT_NE(cellularDataHandler->apnManager_, nullptr); + EXPECT_NE(event->GetSharedObject(), nullptr); + EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTED); + auto stateMachine = cellularDataHandler->connectionManager_->GetActiveConnectionByCid(netInfo->cid); + EXPECT_EQ(stateMachine, nullptr); +} + +/** + * @tc.number HandleUpdateNetInfo_005 + * @tc.name test error branch + * @tc.desc Function test + */ +HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_005, Function | MediumTest | Level3) +{ + EventFwk::MatchingSkills matchingSkills; + matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED); + EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills); + auto cellularDataHandler = std::make_shared(subscriberInfo, 0); + cellularDataHandler->Init(); + auto netInfo = std::make_shared(); + netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID; + netInfo->cid = 100; + sptr apnHolder = cellularDataHandler->apnManager_->GetApnHolder( + cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag)); + EXPECT_NE(apnHolder, nullptr); + apnHolder->SetApnState(PROFILE_STATE_CONNECTED); + sptr connectionManager = std::make_unique(0).release(); + EXPECT_NE(connectionManager, nullptr); + connectionManager->Init(); + auto sm = std::make_shared( + connectionManager, std::make_shared("CellularDataHandlerTest")); + sm->cid_ = 100; + cellularDataHandler->connectionManager_->AddActiveConnectionByCid(sm); + auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, netInfo); + cellularDataHandler->HandleUpdateNetInfo(event); + EXPECT_NE(cellularDataHandler->connectionManager_, nullptr); + EXPECT_NE(cellularDataHandler->apnManager_, nullptr); + EXPECT_NE(event->GetSharedObject(), nullptr); + EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTED); + auto stateMachine = cellularDataHandler->connectionManager_->GetActiveConnectionByCid(netInfo->cid); + EXPECT_NE(stateMachine, nullptr); +} +} // namespace Telephony +} // namespace OHOS \ No newline at end of file diff --git a/test/cellular_state_machine_test.cpp b/test/cellular_state_machine_test.cpp index d45eacb1..55a3e260 100644 --- a/test/cellular_state_machine_test.cpp +++ b/test/cellular_state_machine_test.cpp @@ -791,89 +791,6 @@ HWTEST_F(CellularStateMachineTest, DefaultProcessDataConnectionDrsOrRatChanged_0 EXPECT_EQ(result, false); } -/** - * @tc.number DefaultProcessDataCallListChanged_001 - * @tc.name test function branch - * @tc.desc Function test - */ -HWTEST_F(CellularStateMachineTest, DefaultProcessDataCallListChanged_001, Function | MediumTest | Level1) -{ - if (cellularMachine == nullptr) { - std::shared_ptr machine = std::make_shared(); - cellularMachine = machine->CreateCellularDataConnect(0); - cellularMachine->Init(); - } - auto mDefault = static_cast(cellularMachine->defaultState_.GetRefPtr()); - cellularMachine->TransitionTo(cellularMachine->disconnectingState_); - mDefault->stateMachine_ = cellularMachine; - auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT); - bool result = mDefault->ProcessDataCallListChanged(event); - EXPECT_EQ(result, false); -} - -/** - * @tc.number DefaultProcessDataCallListChanged_002 - * @tc.name test function branch - * @tc.desc Function test - */ -HWTEST_F(CellularStateMachineTest, DefaultProcessDataCallListChanged_002, Function | MediumTest | Level1) -{ - if (cellularMachine == nullptr) { - std::shared_ptr machine = std::make_shared(); - cellularMachine = machine->CreateCellularDataConnect(0); - cellularMachine->Init(); - } - auto mDefault = static_cast(cellularMachine->defaultState_.GetRefPtr()); - cellularMachine = nullptr; - mDefault->stateMachine_ = cellularMachine; - std::shared_ptr dataCallInfo = std::make_shared(); - auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT, dataCallInfo); - bool result = mDefault->ProcessDataCallListChanged(event); - EXPECT_EQ(result, false); -} - -/** - * @tc.number DefaultProcessDataCallListChanged_003 - * @tc.name test function branch - * @tc.desc Function test - */ -HWTEST_F(CellularStateMachineTest, DefaultProcessDataCallListChanged_003, Function | MediumTest | Level1) -{ - if (cellularMachine == nullptr) { - std::shared_ptr machine = std::make_shared(); - cellularMachine = machine->CreateCellularDataConnect(0); - cellularMachine->Init(); - } - auto mDefault = static_cast(cellularMachine->defaultState_.GetRefPtr()); - cellularMachine->TransitionTo(cellularMachine->activatingState_); - mDefault->stateMachine_ = cellularMachine; - std::shared_ptr dataCallInfo = std::make_shared(); - auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT, dataCallInfo); - bool result = mDefault->ProcessDataCallListChanged(event); - EXPECT_EQ(result, true); -} - -/** - * @tc.number DefaultProcessDataCallListChanged_004 - * @tc.name test function branch - * @tc.desc Function test - */ -HWTEST_F(CellularStateMachineTest, DefaultProcessDataCallListChanged_004, Function | MediumTest | Level1) -{ - if (cellularMachine == nullptr) { - std::shared_ptr machine = std::make_shared(); - cellularMachine = machine->CreateCellularDataConnect(0); - cellularMachine->Init(); - } - auto mDefault = static_cast(cellularMachine->defaultState_.GetRefPtr()); - cellularMachine->TransitionTo(cellularMachine->inActiveState_); - mDefault->stateMachine_ = cellularMachine; - std::shared_ptr dataCallInfo = std::make_shared(); - auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT, dataCallInfo); - bool result = mDefault->ProcessDataCallListChanged(event); - EXPECT_EQ(result, true); -} - /** * @tc.number Active_StateBegin_001 * @tc.name test function branch diff --git a/test/fuzztest/updatedisconnectmachine_fuzzer/updatedisconnectmachine_fuzzer.cpp b/test/fuzztest/updatedisconnectmachine_fuzzer/updatedisconnectmachine_fuzzer.cpp index c6066165..ca65ccd0 100644 --- a/test/fuzztest/updatedisconnectmachine_fuzzer/updatedisconnectmachine_fuzzer.cpp +++ b/test/fuzztest/updatedisconnectmachine_fuzzer/updatedisconnectmachine_fuzzer.cpp @@ -69,7 +69,6 @@ void UpdateDisconnectMachineFuzz(const uint8_t *data, size_t size) defaultStatus->ProcessDataConnectionDrsOrRatChanged(event); defaultStatus->ProcessDataConnectionRoamOn(event); defaultStatus->ProcessDataConnectionRoamOff(event); - defaultStatus->ProcessDataCallListChanged(event); } void UpdateActiveMachineWithMyAPI(const uint8_t *data, size_t size) diff --git a/test/zero_branch_test.cpp b/test/zero_branch_test.cpp index 136e56ce..df2b19f7 100644 --- a/test/zero_branch_test.cpp +++ b/test/zero_branch_test.cpp @@ -274,6 +274,7 @@ HWTEST_F(BranchTest, Telephony_CellularDataHandler_003, Function | MediumTest | cellularDataHandler.AttemptEstablishDataConnection(apnHolder); cellularDataHandler.connectionManager_ = nullptr; auto event = AppExecFwk::InnerEvent::Get(0); + cellularDataHandler.HandleUpdateNetInfo(event); cellularDataHandler.ClearConnectionIfRequired(); event = nullptr; cellularDataHandler.MsgEstablishDataConnection(event); @@ -442,6 +443,7 @@ HWTEST_F(BranchTest, Telephony_CellularDataHandler_007, Function | MediumTest | sptr apnHolder = controller.cellularDataHandler_->apnManager_->FindApnHolderById(1); std::string str = ""; controller.cellularDataHandler_->CheckForCompatibleDataConnection(apnHolder); + controller.cellularDataHandler_->HandleUpdateNetInfo(event); controller.cellularDataHandler_->PsRadioEmergencyStateOpen(event); controller.cellularDataHandler_->PsRadioEmergencyStateClose(event); controller.cellularDataHandler_->IsNeedDoRecovery(true); @@ -1382,7 +1384,6 @@ HWTEST_F(BranchTest, Default_Test_01, Function | MediumTest | Level3) ASSERT_FALSE(mDefault->ProcessDataConnectionDrsOrRatChanged(event)); ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOn(event)); ASSERT_FALSE(mDefault->ProcessDataConnectionRoamOff(event)); - ASSERT_FALSE(mDefault->ProcessDataCallListChanged(event)); } /** -- Gitee