telephony_cellular_data/test/cellular_data_handler_test.cpp

/*
 * 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"
#include "cellular_data_controller.h"
#ifdef BASE_POWER_IMPROVEMENT
#include "cellular_data_power_save_mode_subscriber.h"
#endif

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)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    auto netInfo = std::make_shared<SetupDataCallResultInfo>();
    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)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto netInfo = std::make_shared<SetupDataCallResultInfo>();
    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<SetupDataCallResultInfo>(), nullptr);
}

/**
 * @tc.number   HandleUpdateNetInfo_003
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_003, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto netInfo = std::make_shared<SetupDataCallResultInfo>();
    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<SetupDataCallResultInfo>(), nullptr);
    sptr<ApnHolder> 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)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto netInfo = std::make_shared<SetupDataCallResultInfo>();
    netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
    sptr<ApnHolder> 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<SetupDataCallResultInfo>(), 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)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto netInfo = std::make_shared<SetupDataCallResultInfo>();
    netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
    netInfo->cid = 100;
    sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder(
        cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag));
    EXPECT_NE(apnHolder, nullptr);
    apnHolder->SetApnState(PROFILE_STATE_CONNECTED);
    auto connectionManager = std::make_shared<DataConnectionManager>(0);
    EXPECT_NE(connectionManager, nullptr);
    connectionManager->Init();
    auto sm = std::make_shared<CellularDataStateMachine>(
        connectionManager, std::make_shared<TelEventHandler>("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<SetupDataCallResultInfo>(), nullptr);
    EXPECT_EQ(apnHolder->GetApnState(), PROFILE_STATE_CONNECTED);
    auto stateMachine = cellularDataHandler->connectionManager_->GetActiveConnectionByCid(netInfo->cid);
    EXPECT_NE(stateMachine, nullptr);
}

/**
 * @tc.number   HandleUpdateNetInfo_006
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleUpdateNetInfo_006, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto netInfo = std::make_shared<SetupDataCallResultInfo>();
    netInfo->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
    netInfo->cid = 100;
    sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->GetApnHolder(
        cellularDataHandler->apnManager_->FindApnNameByApnId(netInfo->flag));
    EXPECT_NE(apnHolder, nullptr);
    apnHolder->SetApnState(PROFILE_STATE_IDLE);
    cellularDataHandler->ClearConnection(apnHolder, DisConnectionReason::REASON_CLEAR_CONNECTION);
    EXPECT_NE(apnHolder->GetApnState(), PROFILE_STATE_DISCONNECTING);
}

/**
 * @tc.number   HandleRoamingOff_001
 * @tc.name     test roaming off
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    EXPECT_NE(cellularDataHandler, nullptr);
    cellularDataHandler->Init();
    cellularDataHandler->SetCellularDataRoamingEnabled(true);
    auto event = AppExecFwk::InnerEvent::Get(0);
    cellularDataHandler->RoamingStateOff(event);
}

/**
 * @tc.number   HandleRoamingOff_002
 * @tc.name     test roaming off
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleRoamingOff_002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    EXPECT_NE(cellularDataHandler, nullptr);
    cellularDataHandler->Init();
    cellularDataHandler->SetCellularDataRoamingEnabled(false);
    auto event = AppExecFwk::InnerEvent::Get(0);
    cellularDataHandler->RoamingStateOff(event);
}

/**
 * @tc.number   HandleEstablishAllApnsIfConnectable_001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleEstablishAllApnsIfConnectable_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    AppExecFwk::InnerEvent::Pointer msgEvent =
        AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_ESTABLISH_ALL_APNS_IF_CONNECTABLE);
    cellularDataHandler->HandleEstablishAllApnsIfConnectable(msgEvent);
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
}

/**
 * @tc.number   HandleSimEvent_001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    AppExecFwk::InnerEvent::Pointer nullEvent(nullptr, nullptr);
    cellularDataHandler->HandleSimEvent(nullEvent);
    auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DATA_CALL_LIST_CHANGED, 0);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
}

/**
 * @tc.number   HandleSimEvent_002
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 1);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_NE(cellularDataHandler->slotId_, event->GetParam());
}

/**
 * @tc.number   HandleSimEvent_003
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_003, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 0);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_STATE_CHANGE);
}

/**
 * @tc.number   HandleSimEvent_004
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_004, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_RECORDS_LOADED, 0);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_RECORDS_LOADED);
}

/**
 * @tc.number   HandleSimEvent_005
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_005, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NV_REFRESH_FINISHED, 0);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_NV_REFRESH_FINISHED);
}

/**
 * @tc.number   HandleSimEvent_006
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_006, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ACCOUNT_LOADED, 0);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
}

/**
 * @tc.number   HandleSimEvent_007
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_007, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NV_REFRESH_FINISHED, 0);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_NV_REFRESH_FINISHED);
}

/**
 * @tc.number   HandleSimEvent_008
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleSimEvent_008, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NV_REFRESH_FINISHED, 1);
    cellularDataHandler->HandleSimEvent(event);
    EXPECT_EQ(event->GetInnerEventId(), RadioEvent::RADIO_NV_REFRESH_FINISHED);
}

/**
 * @tc.number   ClearConnectionsOnUpdateApns_001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION);
    EXPECT_EQ(cellularDataHandler->apnManager_, nullptr);
}

/**
 * @tc.number   ClearConnectionsOnUpdateApns_002
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, ClearConnectionsOnUpdateApns_002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION);
    EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    cellularDataHandler->apnManager_->allApnItem_.clear();
    cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION);
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    std::vector<sptr<ApnItem>> allApnItem;
    sptr<ApnItem> defaultApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
    allApnItem.push_back(defaultApnItem);
    cellularDataHandler->apnManager_->allApnItem_ = allApnItem;
    EXPECT_NE(cellularDataHandler->apnManager_->GetRilAttachApn(), nullptr);
    cellularDataHandler->ClearConnectionsOnUpdateApns(DisConnectionReason::REASON_RETRY_CONNECTION);
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
}

/**
 * @tc.number   SetCellularDataRoamingEnabledTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, SetCellularDataRoamingEnabledTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    bool dataRoamingEnabled = true;
    EXPECT_EQ(cellularDataHandler->SetCellularDataRoamingEnabled(dataRoamingEnabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(0);
    cellularDataHandler->RadioPsConnectionAttached(event);
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    cellularDataHandler->RoamingStateOn(event);
    cellularDataHandler->RoamingStateOff(event);
    EXPECT_NE(cellularDataHandler->dataSwitchSettings_, nullptr);
    cellularDataHandler->incallDataStateMachine_ = cellularDataHandler->CreateIncallDataStateMachine(0);
    EXPECT_FALSE(cellularDataHandler->SetDataPermittedForMms(true));
}

/**
 * @tc.number   AttemptEstablishDataConnectionTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    std::shared_ptr<CellularDataStateMachine> cellularMachine = nullptr;
    cellularDataHandler->connectionManager_->GetAllConnectionMachine().push_back(cellularMachine);
    EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr);
}

/**
 * @tc.number   AttemptEstablishDataConnectionTest002
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, AttemptEstablishDataConnectionTest002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    auto connectionManager = std::make_shared<DataConnectionManager>(0);
    std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
        connectionManager, nullptr);
    cellularDataHandler->connectionManager_ = connectionManager;
    cellularDataHandler->connectionManager_->GetAllConnectionMachine().push_back(cellularMachine);
    EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr);
    cellularDataHandler->Init();
    EXPECT_EQ(cellularDataHandler->FindIdleCellularDataConnection(), nullptr);
}

/**
 * @tc.number   EstablishDataConnectionTest002
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, EstablishDataConnectionTest002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
    sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    apnHolder->retryPolicy_.matchedApns_.push_back(apnItem);
    EXPECT_NE(apnHolder->GetNextRetryApn(), nullptr);
    EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0));
    apnHolder->apnType_ = DATA_CONTEXT_ROLE_DUN;
    EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0));
    apnHolder->apnType_ = DATA_CONTEXT_ROLE_MMS;
    EXPECT_TRUE(cellularDataHandler->EstablishDataConnection(apnHolder, 0));
}

/**
 * @tc.number   DisconnectDataCompleteTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, DisconnectDataCompleteTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    auto event = AppExecFwk::InnerEvent::Get(0);
    cellularDataHandler->DisconnectDataComplete(event);
    EXPECT_NE(event, nullptr);
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
}

/**
 * @tc.number   UpdatePhysicalConnectionStateTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, UpdatePhysicalConnectionStateTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->physicalConnectionActiveState_ = false;
    cellularDataHandler->UpdatePhysicalConnectionState(false);
    EXPECT_TRUE(cellularDataHandler->physicalConnectionActiveState_);

    cellularDataHandler->UpdatePhysicalConnectionState(true);
    EXPECT_FALSE(cellularDataHandler->physicalConnectionActiveState_);

    cellularDataHandler->physicalConnectionActiveState_ = true;
    cellularDataHandler->UpdatePhysicalConnectionState(false);
    EXPECT_TRUE(cellularDataHandler->physicalConnectionActiveState_);

    cellularDataHandler->UpdatePhysicalConnectionState(true);
    EXPECT_FALSE(cellularDataHandler->physicalConnectionActiveState_);
}

/**
 * @tc.number   HandleScreenStateChangedTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleScreenStateChangedTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->HandleScreenStateChanged(false);
    EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr);
    cellularDataHandler->Init();
    cellularDataHandler->HandleScreenStateChanged(false);
    EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
}

/**
 * @tc.number   UpdateCellularDataConnectStateTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, UpdateCellularDataConnectStateTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    cellularDataHandler->incallDataStateMachine_ = cellularDataHandler->CreateIncallDataStateMachine(0);
    AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
    cellularDataHandler->IncallDataComplete(event);
    EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr);
    cellularDataHandler->UpdateCellularDataConnectState("default");
    EXPECT_EQ(cellularDataHandler->apnManager_->GetOverallDefaultApnState(), 0);
    cellularDataHandler->UpdateCellularDataConnectState("internal_default");
    EXPECT_EQ(cellularDataHandler->apnManager_->GetOverallDefaultApnState(), 0);
}

/**
 * @tc.number   HandleImsCallChangedTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HandleImsCallChangedTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    cellularDataHandler->HandleImsCallChanged(1);
    EXPECT_EQ(cellularDataHandler->incallDataStateMachine_, nullptr);
    cellularDataHandler->HandleImsCallChanged(4);
    EXPECT_NE(cellularDataHandler->incallDataStateMachine_, nullptr);
    cellularDataHandler->HandleImsCallChanged(2);
    EXPECT_NE(cellularDataHandler->incallDataStateMachine_->GetCallState(), 8);
    cellularDataHandler->HandleImsCallChanged(4);
    EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 4);
    cellularDataHandler->HandleImsCallChanged(6);
    EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 6);
    cellularDataHandler->HandleImsCallChanged(8);
    EXPECT_EQ(cellularDataHandler->incallDataStateMachine_->GetCallState(), 8);
}

/**
 * @tc.number   PsDataRatChangedTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, PsDataRatChangedTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
    cellularDataHandler->PsDataRatChanged(event);
    cellularDataHandler->dataSwitchSettings_->userDataOn_ = false;
    EXPECT_FALSE(cellularDataHandler->dataSwitchSettings_->IsUserDataOn());
}

/**
 * @tc.number   SetPolicyDataOnTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, SetPolicyDataOnTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    cellularDataHandler->dataSwitchSettings_->policyDataOn_ = false;
    cellularDataHandler->SetPolicyDataOn(true);
    EXPECT_TRUE(cellularDataHandler->dataSwitchSettings_->IsUserDataOn());
    cellularDataHandler->dataSwitchSettings_->policyDataOn_ = true;
    cellularDataHandler->SetPolicyDataOn(false);
    EXPECT_FALSE(cellularDataHandler->dataSwitchSettings_->policyDataOn_);
}

/**
 * @tc.number   SetRilAttachApnTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, SetRilAttachApnTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    sptr<ApnItem> attachApn = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
    cellularDataHandler->apnManager_->allApnItem_.push_back(attachApn);
    cellularDataHandler->SetRilAttachApn();
}

/**
 * @tc.number   HasAnyHigherPriorityConnectionTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    sortApnHolder->priority_ = 1;
    sortApnHolder->dataCallEnabled_ = true;
    sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_CONNECTED;
    cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder);
    sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    apnHolder->priority_ = 0;
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true);
    EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder));
}

/**
 * @tc.number   HasAnyHigherPriorityConnectionTest002
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    sortApnHolder->priority_ = 1;
    sortApnHolder->dataCallEnabled_ = true;
    sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_CONNECTING;
    cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder);
    sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    apnHolder->priority_ = 0;
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true);
    EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder));
}

/**
 * @tc.number   HasAnyHigherPriorityConnectionTest003
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HasAnyHigherPriorityConnectionTest003, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    sptr<ApnHolder> sortApnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    sortApnHolder->priority_ = 1;
    sortApnHolder->dataCallEnabled_ = true;
    sortApnHolder->apnState_ = ApnProfileState::PROFILE_STATE_DISCONNECTING;
    cellularDataHandler->apnManager_->sortedApnHolders_.push_back(sortApnHolder);
    sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    apnHolder->priority_ = 0;
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
    EXPECT_NE(cellularDataHandler->apnManager_->GetSortApnHolder().empty(), true);
    EXPECT_TRUE(cellularDataHandler->HasAnyHigherPriorityConnection(apnHolder));
}

/**
 * @tc.number   HasInternetCapabilityTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    auto connectionManager = std::make_shared<DataConnectionManager>(0);
    std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
        connectionManager, nullptr);
    cellularMachine->capability_ = NetCap::NET_CAPABILITY_INTERNET;
    cellularDataHandler->connectionManager_->cidActiveConnectionMap_[0] = cellularMachine;
    EXPECT_NE(cellularDataHandler->connectionManager_->GetActiveConnectionByCid(0), nullptr);
    EXPECT_TRUE(cellularDataHandler->HasInternetCapability(0));
}

/**
 * @tc.number   HasInternetCapabilityTest002
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, HasInternetCapabilityTest002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    auto connectionManager = std::make_shared<DataConnectionManager>(0);
    std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
        connectionManager, nullptr);
    cellularMachine->capability_ = NetCap::NET_CAPABILITY_MMS;
    cellularDataHandler->connectionManager_->cidActiveConnectionMap_[0] = cellularMachine;
    EXPECT_NE(cellularDataHandler->connectionManager_->GetActiveConnectionByCid(0), nullptr);
    EXPECT_FALSE(cellularDataHandler->HasInternetCapability(0));
}

/**
 * @tc.number   ChangeConnectionForDsdsTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, ChangeConnectionForDsdsTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    cellularDataHandler->ChangeConnectionForDsds(true);
    EXPECT_TRUE(cellularDataHandler->dataSwitchSettings_->internalDataOn_);
}

/**
 * @tc.number   GetDataConnApnAttrTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, GetDataConnApnAttrTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    sptr<ApnHolder> apnHolder1 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    apnHolder1->apnItem_ = nullptr;
    apnHolder1->dataCallEnabled_ = true;
    cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder1);
    sptr<ApnHolder> apnHolder2 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    sptr<ApnItem> apnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
    apnItem->attr_.isEdited_ = true;
    apnHolder2->apnItem_ = apnItem;
    apnHolder2->dataCallEnabled_ = true;
    cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder2);
    ApnItem::Attribute apnAttr;
    apnAttr.isEdited_ = false;
    cellularDataHandler->GetDataConnApnAttr(apnAttr);
    EXPECT_TRUE(apnAttr.isEdited_);
}

/**
 * @tc.number   GetDataConnIpTypeTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, GetDataConnIpTypeTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    cellularDataHandler->Init();
    sptr<ApnHolder> apnHolder1 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    apnHolder1->cellularDataStateMachine_ = nullptr;
    apnHolder1->dataCallEnabled_ = true;
    cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder1);
    sptr<ApnHolder> apnHolder2 = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    auto connectionManager = std::make_shared<DataConnectionManager>(0);
    std::shared_ptr<CellularDataStateMachine> cellularMachine = std::make_shared<CellularDataStateMachine>(
        connectionManager, nullptr);
    cellularMachine->ipType_ = "IPV4";
    apnHolder2->cellularDataStateMachine_ = cellularMachine;
    apnHolder2->dataCallEnabled_ = true;
    cellularDataHandler->apnManager_->apnHolders_.push_back(apnHolder2);
    cellularDataHandler->GetDataConnIpType();
    EXPECT_EQ(cellularDataHandler->GetDataConnIpType(), "IPV4");
}

/**
 * @tc.number   CheckForCompatibleDataConnectionTest001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, CheckForCompatibleDataConnectionTest001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(1);
    sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>("default", static_cast<int32_t>(0)).release();
    apnHolder->apnType_ = DATA_CONTEXT_ROLE_DUN;
    EXPECT_EQ(cellularDataHandler->CheckForCompatibleDataConnection(apnHolder), nullptr);
    cellularDataHandler->Init();
    EXPECT_EQ(cellularDataHandler->CheckForCompatibleDataConnection(apnHolder), nullptr);
}

/**
 * @tc.number   UpdateNetworkInfo_001
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    EXPECT_EQ(cellularDataHandler->connectionManager_, nullptr);
    EXPECT_FALSE(cellularDataHandler->UpdateNetworkInfo());
}

/**
 * @tc.number   UpdateNetworkInfo_002
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, UpdateNetworkInfo_002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    EXPECT_NE(cellularDataHandler->connectionManager_, nullptr);
    EXPECT_TRUE(cellularDataHandler->UpdateNetworkInfo());
}

/**
 * @tc.number   Telephony_MsgRequest
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, Telephony_MsgRequest, Function | MediumTest | Level1)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    NetRequest request1;
    request1.capability = NetManagerStandard::NET_CAPABILITY_INTERNET;

    EXPECT_TRUE(cellularDataHandler->RequestNet(request1));
    NetRequest request2;
    request2.capability = NetManagerStandard::NET_CAPABILITY_INTERNET;
    EXPECT_TRUE(cellularDataHandler->RequestNet(request2));
    sleep(2);
}

/**
 * @tc.number   Telephony_ConnectIfNeed
 * @tc.name     test error branch
 * @tc.desc     Function test
 */
HWTEST_F(CellularDataHandlerTest, Telephony_ConnectIfNeed, Function | MediumTest | Level1)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();

    NetRequest request1;
    request1.capability = NetManagerStandard::NET_CAPABILITY_INTERNET;
    EXPECT_TRUE(cellularDataHandler->RequestNet(request1));
    auto event1 = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_REQUEST_NETWORK, TYPE_REQUEST_NET);
    auto apnHolder =
        cellularDataHandler->apnManager_->FindApnHolderById(ApnManager::FindApnIdByCapability(request1.capability));
}

HWTEST_F(CellularDataHandlerTest, Telephony_CellularDataHandler_003, Function | MediumTest | Level1)
{
    CellularDataController controller {0};
    controller.Init();
    ApnActivateReportInfo info1;
    ApnActivateReportInfo info2;
    EXPECT_TRUE(controller.GetDefaultActReportInfo(info1));
    EXPECT_TRUE(controller.GetInternalActReportInfo(info2));
    controller.cellularDataHandler_ = nullptr;
    EXPECT_FALSE(controller.GetDefaultActReportInfo(info1));
    EXPECT_FALSE(controller.GetInternalActReportInfo(info2));
}

HWTEST_F(CellularDataHandlerTest, DataConnCompleteUpdateStateTest001, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    std::string apnType = DATA_CONTEXT_ROLE_MMS;
    sptr<ApnHolder> apnHolder = new ApnHolder(apnType, slotId);
    apnHolder->cellularDataStateMachine_ = nullptr;
    auto resultInfo = std::make_shared<SetupDataCallResultInfo>();
    cellularDataHandler->connectionManager_ = nullptr;
    cellularDataHandler->physicalConnectionActiveState_ = true;
    cellularDataHandler->incallDataStateMachine_ = nullptr;
    cellularDataHandler->DataConnCompleteUpdateState(apnHolder, resultInfo);
    EXPECT_FALSE(cellularDataHandler->isRilApnAttached_);

    std::shared_ptr<DataConnectionManager> cdConnectionManager = nullptr;
    std::shared_ptr<TelEventHandler> telEventHandler = nullptr;
    apnHolder->cellularDataStateMachine_ = std::make_shared<CellularDataStateMachine>
        (cdConnectionManager, std::move(telEventHandler));
    apnHolder->cellularDataStateMachine_->netLinkInfo_ = new NetLinkInfo();
    apnHolder->cellularDataStateMachine_->netSupplierInfo_ = nullptr;
    cellularDataHandler->apnManager_ = std::make_unique<ApnManager>().release();
    cellularDataHandler->apnManager_->allApnItem_.clear();
    cellularDataHandler->connectionManager_ = std::make_shared<DataConnectionManager>(slotId);
    cellularDataHandler->physicalConnectionActiveState_ = false;
    cellularDataHandler->incallDataStateMachine_ =
        cellularDataHandler->CreateIncallDataStateMachine(TelCallStatus::CALL_STATUS_DIALING);
    apnHolder->apnType_ = DATA_CONTEXT_ROLE_DEFAULT;
    apnHolder->apnItem_ = new ApnItem();
    cellularDataHandler->DataConnCompleteUpdateState(apnHolder, resultInfo);

    cellularDataHandler->apnManager_->preferId_ = 1;
    cellularDataHandler->apnManager_->allApnItem_.push_back(new ApnItem());
    cellularDataHandler->DataConnCompleteUpdateState(apnHolder, resultInfo);
    EXPECT_FALSE(cellularDataHandler->isRilApnAttached_);
}

/**
@tc.number Telephony_CreateApnItem
@tc.name CreateApnItem
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CreateApnItemTest001, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->apnManager_ = nullptr;
    cellularDataHandler->CreateApnItem();

    cellularDataHandler->Init();
    EXPECT_FALSE(cellularDataHandler->apnManager_ == nullptr);
    cellularDataHandler->CreateApnItem();
    cellularDataHandler->SendEvent(CellularDataEventCode::MSG_RETRY_TO_CREATE_APN, 0, RETRY_DELAY_TIME);
    cellularDataHandler->CreateApnItem();
    EXPECT_FALSE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_CREATE_APN));
}

HWTEST_F(CellularDataHandlerTest, CreateApnItemTest002, Function | MediumTest | Level1)
{
    int32_t slotId = 2;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
 
    cellularDataHandler->Init();
    cellularDataHandler->retryCreateApnTimes_ = 3;
    cellularDataHandler->CreateApnItem();
    cellularDataHandler->RemoveEvent(CellularDataEventCode::MSG_RETRY_TO_CREATE_APN);
    cellularDataHandler->retryCreateApnTimes_ = 2;
    cellularDataHandler->CreateApnItem();
    EXPECT_NE(cellularDataHandler->apnManager_, nullptr);
}

/**
@tc.number Telephony_IsCellularDataEnabled
@tc.name IsCellularDataEnabled
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, IsCellularDataEnabledTest001, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    bool isDataEnabled = false;
    EXPECT_NE(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS);

    cellularDataHandler->Init();
    cellularDataHandler->dataSwitchSettings_->lastQryRet_ = -1;
    EXPECT_EQ(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS);
    cellularDataHandler->dataSwitchSettings_->lastQryRet_ = TELEPHONY_ERR_SUCCESS;
    EXPECT_EQ(cellularDataHandler->IsCellularDataEnabled(isDataEnabled), TELEPHONY_ERR_SUCCESS);
}

/**
@tc.number Telephony_CheckApnActivate
@tc.name CheckApnActivate001
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CheckApnActivate001, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->Init();
    cellularDataHandler->SetApnActivateStart(DATA_CONTEXT_ROLE_DEFAULT);
    cellularDataHandler->SetApnActivateStart(DATA_CONTEXT_ROLE_INTERNAL_DEFAULT);
    auto resultInfo1 = std::make_shared<SetupDataCallResultInfo>();
    resultInfo1->flag = DATA_CONTEXT_ROLE_INTERNAL_DEFAULT_ID;
    resultInfo1->reason = 0;
    cellularDataHandler->SetApnActivateEnd(resultInfo1);
    auto resultInfo2 = std::make_shared<SetupDataCallResultInfo>();
    resultInfo2->flag = DATA_CONTEXT_ROLE_INTERNAL_DEFAULT_ID;
    resultInfo2->reason = 1;
    cellularDataHandler->SetApnActivateEnd(resultInfo2);
    auto resultInfo3 = std::make_shared<SetupDataCallResultInfo>();
    resultInfo3->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
    resultInfo3->reason = 2;
    cellularDataHandler->SetApnActivateEnd(resultInfo3);
    auto resultInfo4 = std::make_shared<SetupDataCallResultInfo>();
    resultInfo4->flag = DATA_CONTEXT_ROLE_DEFAULT_ID;
    resultInfo4->reason = 2;
    cellularDataHandler->SetApnActivateEnd(resultInfo4);
    cellularDataHandler->GetApnActReportInfo(DATA_CONTEXT_ROLE_DEFAULT_ID);
    cellularDataHandler->GetApnActReportInfo(DATA_CONTEXT_ROLE_INTERNAL_DEFAULT_ID);
    int32_t listLen = 4;
    EXPECT_EQ(cellularDataHandler->apnActivateChrList_.size(), listLen);
}

/**
@tc.number Telephony_CheckApnActivate002
@tc.name CheckApnActivate002
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CheckApnActivate002, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->Init();
    ApnActivateInfo info1;
    info1.reason = 0;
    info1.actSuccTime = 0;
    info1.apnId = 1;
    info1.duration = 0;
    cellularDataHandler->apnActivateChrList_.push_back(info1);
    cellularDataHandler->EraseApnActivateList();
    EXPECT_EQ(cellularDataHandler->apnActivateChrList_.size(), 0);
}

/**
@tc.number Telephony_CheckMultiApnState
@tc.name CheckMultiApnState001
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CheckMultiApnState001, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->Init();
    sptr<ApnManager> apnManager = cellularDataHandler->apnManager_;
    if (apnManager == nullptr) {
        EXPECT_EQ(apnManager, nullptr);
    } else {
        sptr<ApnHolder> defaultApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
        bool result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, false);
        sptr<ApnHolder> bipApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_BIP);
        result = cellularDataHandler->CheckMultiApnState(bipApnHolder);
        EXPECT_EQ(result, false);
    }
}

/**
@tc.number Telephony_CheckMultiApnState
@tc.name CheckMultiApnState002
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CheckMultiApnState002, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->Init();
    sptr<ApnManager> apnManager = cellularDataHandler->apnManager_;
    if (apnManager == nullptr) {
        EXPECT_EQ(apnManager, nullptr);
    } else {
        sptr<ApnHolder> defaultApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
        sptr<ApnHolder> bipApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_BIP);
        bipApnHolder->SetApnState(PROFILE_STATE_DISCONNECTING);
        bool result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, true);
        bipApnHolder->SetApnState(PROFILE_STATE_CONNECTED);
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, true);
        bipApnHolder->SetApnState(PROFILE_STATE_CONNECTING);
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, true);
        bipApnHolder->SetApnState(PROFILE_STATE_IDLE);
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, false);
        cellularDataHandler->apnManager_ = nullptr;
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, false);
    }
}

/**
@tc.number Telephony_CheckMultiApnState
@tc.name CheckMultiApnState003
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CheckMultiApnState003, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->Init();
    sptr<ApnManager> apnManager = cellularDataHandler->apnManager_;
    if (apnManager == nullptr) {
        EXPECT_EQ(apnManager, nullptr);
    } else {
        sptr<ApnHolder> defaultApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
        cellularDataHandler->apnManager_ = nullptr;
        bool result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, false);
    }
}

/**
@tc.number Telephony_CheckMultiApnState
@tc.name CheckMultiApnState004
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CheckMultiApnState004, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->Init();
    sptr<ApnManager> apnManager = cellularDataHandler->apnManager_;
    if (apnManager == nullptr) {
        EXPECT_EQ(apnManager, nullptr);
    } else {
        sptr<ApnHolder> defaultApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
        bool result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, false);
        sptr<ApnHolder> dunApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DUN);
        result = cellularDataHandler->CheckMultiApnState(dunApnHolder);
        EXPECT_EQ(result, false);
    }
}

/**
@tc.number Telephony_CheckMultiApnState
@tc.name CheckMultiApnState005
@tc.desc Function test
*/
HWTEST_F(CellularDataHandlerTest, CheckMultiApnState005, Function | MediumTest | Level1)
{
    int32_t slotId = 0;
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(slotId);
    cellularDataHandler->Init();
    sptr<ApnManager> apnManager = cellularDataHandler->apnManager_;
    if (apnManager == nullptr) {
        EXPECT_EQ(apnManager, nullptr);
    } else {
        sptr<ApnHolder> defaultApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DEFAULT);
        sptr<ApnHolder> dunApnHolder = apnManager->GetApnHolder(DATA_CONTEXT_ROLE_DUN);
        dunApnHolder->SetApnState(PROFILE_STATE_DISCONNECTING);
        bool result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, true);
        dunApnHolder->SetApnState(PROFILE_STATE_CONNECTED);
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, true);
        dunApnHolder->SetApnState(PROFILE_STATE_CONNECTING);
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, true);
        dunApnHolder->SetApnState(PROFILE_STATE_IDLE);
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, false);
        cellularDataHandler->apnManager_ = nullptr;
        result = cellularDataHandler->CheckMultiApnState(defaultApnHolder);
        EXPECT_EQ(result, false);
    }
}

HWTEST_F(CellularDataHandlerTest, HandleRetryLoadSimAccount001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    auto event0 = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT);
    auto event1 = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);

    // false false
    cellularDataHandler->isSimAccountLoaded_ = false;
    cellularDataHandler->HandleRetryLoadSimAccount(event0);
    EXPECT_FALSE(cellularDataHandler->isSimAccountLoaded_);

    // true false
    cellularDataHandler->SendEvent(event0, 5000);
    cellularDataHandler->HandleRetryLoadSimAccount(event0);
    EXPECT_TRUE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->RemoveEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT);

    // false true
    cellularDataHandler->isSimAccountLoaded_ = false;
    cellularDataHandler->SendEvent(event1, 5000);
    cellularDataHandler->HandleRetryLoadSimAccount(event0);
    EXPECT_TRUE(cellularDataHandler->HasInnerEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED));
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);

    // true true
    cellularDataHandler->isSimAccountLoaded_ = true;
    cellularDataHandler->SendEvent(event1, 5000);
    cellularDataHandler->HandleRetryLoadSimAccount(event0);
    EXPECT_FALSE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
}

/**
* @tc.number   OnDataShareReady_001
* @tc.name     Test OnDataShareReady - isSimAccountLoaded_ is false, no RADIO_SIM_ACCOUNT_LOADED event
* @tc.desc     Branch coverage test: should start load sim account timer
*/
HWTEST_F(CellularDataHandlerTest, OnDataShareReady_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->isSimAccountLoaded_ = false;
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
    cellularDataHandler->OnDataShareReady();
    EXPECT_TRUE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->StopLoadSimAccountTimer();
}

/**
* @tc.number   OnDataShareReady_002
* @tc.name     Test OnDataShareReady - isSimAccountLoaded_ is true
* @tc.desc     Branch coverage test: should not start load sim account timer
*/
HWTEST_F(CellularDataHandlerTest, OnDataShareReady_002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->isSimAccountLoaded_ = true;
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
    cellularDataHandler->OnDataShareReady();
    EXPECT_FALSE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
}

/**
* @tc.number   OnDataShareReady_003
* @tc.name     Test OnDataShareReady - has RADIO_SIM_ACCOUNT_LOADED event
* @tc.desc     Branch coverage test: should not start load sim account timer
*/
HWTEST_F(CellularDataHandlerTest, OnDataShareReady_003, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->isSimAccountLoaded_ = false;
    auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
    cellularDataHandler->SendEvent(event, 5000);
    cellularDataHandler->OnDataShareReady();
    EXPECT_FALSE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
}

/**
* @tc.number   StartLoadSimAccountTimer_001
* @tc.name     Test StartLoadSimAccountTimer - times <= 0
* @tc.desc     Branch coverage test: should return early
*/
HWTEST_F(CellularDataHandlerTest, StartLoadSimAccountTimer_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->StartLoadSimAccountTimer(0);
    EXPECT_FALSE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->StartLoadSimAccountTimer(-1);
    EXPECT_FALSE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
}

/**
* @tc.number   StartLoadSimAccountTimer_002
* @tc.name     Test StartLoadSimAccountTimer - times > 0, no existing event
* @tc.desc     Branch coverage test: should send event
*/
HWTEST_F(CellularDataHandlerTest, StartLoadSimAccountTimer_002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->StopLoadSimAccountTimer();
    cellularDataHandler->StartLoadSimAccountTimer(1);
    EXPECT_TRUE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->StopLoadSimAccountTimer();
}

/**
* @tc.number   StartLoadSimAccountTimer_003
* @tc.name     Test StartLoadSimAccountTimer - times > 0, has existing event
* @tc.desc     Branch coverage test: should not send duplicate event
*/
HWTEST_F(CellularDataHandlerTest, StartLoadSimAccountTimer_003, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->StartLoadSimAccountTimer(1);
    EXPECT_TRUE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->StartLoadSimAccountTimer(2);
    EXPECT_TRUE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->StopLoadSimAccountTimer();
}

/**
* @tc.number   HandleRetryLoadSimAccount_002
* @tc.name     Test HandleRetryLoadSimAccount - event is nullptr
* @tc.desc     Branch coverage test: should return early
*/
HWTEST_F(CellularDataHandlerTest, HandleRetryLoadSimAccount_002, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->isSimAccountLoaded_ = false;
    auto event = AppExecFwk::InnerEvent::Get(0);
    event = nullptr;
    cellularDataHandler->HandleRetryLoadSimAccount(event);
    EXPECT_FALSE(cellularDataHandler->isSimAccountLoaded_);
}

/**
* @tc.number   HandleRetryLoadSimAccount_003
* @tc.name     Test HandleRetryLoadSimAccount - simId <= INVALID_SIM_ID with retry times
* @tc.desc     Branch coverage test: should retry with times - 1
*/
HWTEST_F(CellularDataHandlerTest, HandleRetryLoadSimAccount_003, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(-1);
    auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT, 2);
    cellularDataHandler->isSimAccountLoaded_ = false;
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
    cellularDataHandler->HandleRetryLoadSimAccount(event);
    EXPECT_FALSE(cellularDataHandler->isSimAccountLoaded_);
}

/**
* @tc.number   HandleRetryLoadSimAccount_004
* @tc.name     Test HandleRetryLoadSimAccount - simId > INVALID_SIM_ID, isSimAccountLoaded_ is true
* @tc.desc     Branch coverage test: should not call HandleSimAccountLoaded
*/
HWTEST_F(CellularDataHandlerTest, HandleRetryLoadSimAccount_004, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(-1);
    auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT);
    cellularDataHandler->isSimAccountLoaded_ = true;
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
    cellularDataHandler->HandleRetryLoadSimAccount(event);
    EXPECT_TRUE(cellularDataHandler->isSimAccountLoaded_);
}

/**
* @tc.number   HandleRetryLoadSimAccount_005
* @tc.name     Test HandleRetryLoadSimAccount - simId > INVALID_SIM_ID, has RADIO_SIM_ACCOUNT_LOADED event
* @tc.desc     Branch coverage test: should not call HandleSimAccountLoaded
*/
HWTEST_F(CellularDataHandlerTest, HandleRetryLoadSimAccount_005, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(-1);
    auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT);
    auto simEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
    cellularDataHandler->isSimAccountLoaded_ = false;
    cellularDataHandler->SendEvent(simEvent, 5000);
    cellularDataHandler->HandleRetryLoadSimAccount(event);
    EXPECT_FALSE(cellularDataHandler->isSimAccountLoaded_);
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
}

/**
* @tc.number   HandleRetryLoadSimAccount_006
* @tc.name     Test HandleRetryLoadSimAccount - simId > INVALID_SIM_ID, has RADIO_SIM_ACCOUNT_LOADED event
* @tc.desc     Branch coverage test: should not call HandleSimAccountLoaded
*/
HWTEST_F(CellularDataHandlerTest, HandleRetryLoadSimAccount_006, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(-1);
    auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT);
    auto simEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
    cellularDataHandler->isSimAccountLoaded_ = true;
    cellularDataHandler->SendEvent(simEvent, 5000);
    cellularDataHandler->HandleRetryLoadSimAccount(event);
    EXPECT_TRUE(cellularDataHandler->isSimAccountLoaded_);
    cellularDataHandler->RemoveEvent(RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
}

/**
* @tc.number   StopLoadSimAccountTimer_001
* @tc.name     Test StopLoadSimAccountTimer - remove event
* @tc.desc     Branch coverage test: should remove MSG_RETRY_TO_LOAD_SIM_ACCOUNT event
*/
HWTEST_F(CellularDataHandlerTest, StopLoadSimAccountTimer_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->StartLoadSimAccountTimer(1);
    EXPECT_TRUE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
    cellularDataHandler->StopLoadSimAccountTimer();
    EXPECT_FALSE(cellularDataHandler->HasInnerEvent(CellularDataEventCode::MSG_RETRY_TO_LOAD_SIM_ACCOUNT));
}

HWTEST_F(CellularDataHandlerTest, MsgRequestNetwork001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->apnManager_ = sptr<ApnManager>::MakeSptr();
    cellularDataHandler->apnManager_->InitApnHolders();
    std::unique_ptr<NetRequest> netRequest = std::make_unique<NetRequest>();
    netRequest->capability = NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET;
    sptr<ApnHolder> apnHolder = cellularDataHandler->apnManager_->FindApnHolderById(DATA_CONTEXT_ROLE_DEFAULT_ID);
    ASSERT_NE(apnHolder, nullptr);
    apnHolder->dataCallEnabled_ = true;
    AppExecFwk::InnerEvent::Pointer event =
        AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_REQUEST_NETWORK, netRequest, TYPE_RELEASE_NET);
    cellularDataHandler->MsgRequestNetwork(event);
    EXPECT_FALSE(apnHolder->dataCallEnabled_);
}

HWTEST_F(CellularDataHandlerTest, IsBlockSetRilAttachApn_001, Function | MediumTest | Level3)
{
    auto cellularDataHandler = std::make_shared<CellularDataHandler>(0);
    cellularDataHandler->Init();
    cellularDataHandler->lastNumeric_ = "00101";
    EXPECT_FALSE(cellularDataHandler->IsBlockSetRilAttachApn());
 
    cellularDataHandler->lastNumeric_ = "99999";
    EXPECT_FALSE(cellularDataHandler->IsBlockSetRilAttachApn());
}

} // namespace Telephony
} // namespace OHOS