mirror of
https://github.com/openharmony/telephony_cellular_data.git
synced 2026-08-25 09:04:03 -04:00
benlau000
858 lines
35 KiB
C++
858 lines
35 KiB
C++
/*
|
|
* 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 "activating.h"
|
|
#include "active.h"
|
|
#include "apn_manager.h"
|
|
#include "cellular_data_state_machine.h"
|
|
#include "data_connection_manager.h"
|
|
#include "default.h"
|
|
#include "disconnecting.h"
|
|
#include "gtest/gtest.h"
|
|
#include "inactive.h"
|
|
#include "incall_data_state_machine.h"
|
|
#include "tel_event_handler.h"
|
|
#include "telephony_types.h"
|
|
|
|
namespace OHOS {
|
|
namespace Telephony {
|
|
using namespace testing::ext;
|
|
|
|
static const int32_t SLEEP_TIME = 3;
|
|
|
|
class CellularStateMachineTest : public testing::Test {
|
|
public:
|
|
static void SetUpTestCase();
|
|
static void TearDownTestCase();
|
|
void SetUp();
|
|
void TearDown();
|
|
std::shared_ptr<CellularDataStateMachine> cellularMachine;
|
|
};
|
|
void CellularStateMachineTest::SetUpTestCase() {}
|
|
|
|
void CellularStateMachineTest::TearDownTestCase()
|
|
{
|
|
sleep(SLEEP_TIME);
|
|
}
|
|
|
|
void CellularStateMachineTest::SetUp() {}
|
|
|
|
void CellularStateMachineTest::TearDown() {}
|
|
|
|
class CellularMachineTest : public TelEventHandler {
|
|
public:
|
|
CellularMachineTest() : TelEventHandler("CellularDataStateMachineTest") {}
|
|
~CellularMachineTest() = default;
|
|
std::shared_ptr<CellularDataStateMachine> CreateCellularDataConnect(int32_t slotId);
|
|
|
|
public:
|
|
std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine_ = nullptr;
|
|
};
|
|
|
|
std::shared_ptr<CellularDataStateMachine> CellularMachineTest::CreateCellularDataConnect(int32_t slotId)
|
|
{
|
|
if (cellularDataStateMachine_ != nullptr) {
|
|
return cellularDataStateMachine_;
|
|
}
|
|
auto connectionManager = std::make_shared<DataConnectionManager>(slotId);
|
|
if (connectionManager == nullptr) {
|
|
return nullptr;
|
|
}
|
|
connectionManager->Init();
|
|
cellularDataStateMachine_ = std::make_shared<CellularDataStateMachine>(
|
|
connectionManager, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
|
|
return cellularDataStateMachine_;
|
|
}
|
|
|
|
/**
|
|
* @tc.number Active_RefreshTcpBufferSizes_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Active_RefreshTcpBufferSizes_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto active = std::static_pointer_cast<Active>(cellularMachine->activeState_);
|
|
active->stateMachine_ = cellularMachine;
|
|
active->RefreshTcpBufferSizes();
|
|
ASSERT_TRUE(cellularMachine != nullptr);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_StateBegin_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_StateBegin_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
activating->stateMachine_ = cellularMachine;
|
|
activating->StateBegin();
|
|
EXPECT_EQ(activating->isActive_, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_StateProcess_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_StateProcess_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DRS_OR_RAT_CHANGED);
|
|
bool result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT);
|
|
result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_SETUP_DATA_CALL);
|
|
result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, false);
|
|
event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_GET_LAST_FAIL_DONE);
|
|
result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_GET_RIL_BANDWIDTH);
|
|
result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, false);
|
|
event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_CONNECT_TIMEOUT_CHECK);
|
|
result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(0);
|
|
result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_ProcessConnectTimeout_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT, 1);
|
|
activating->ProcessConnectTimeout(event);
|
|
EXPECT_EQ(cellularMachine->stateMachineEventHandler_->destState_, cellularMachine->inActiveState_);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_ProcessConnectTimeout_002
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_002, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->TransitionTo(cellularMachine->disconnectingState_);
|
|
cellularMachine = nullptr;
|
|
activating->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(1);
|
|
activating->ProcessConnectTimeout(event);
|
|
EXPECT_EQ(cellularMachine == nullptr, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_ProcessConnectTimeout_003
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_003, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
EXPECT_NE(machine, nullptr);
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
cellularMachine->TransitionTo(cellularMachine->disconnectingState_);
|
|
activating->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(0);
|
|
activating->ProcessConnectTimeout(event);
|
|
cellularMachine->IsInactiveState();
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_CellularDataStateMachine_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_CellularDataStateMachine_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine = nullptr;
|
|
activating->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(0);
|
|
activating->StateBegin();
|
|
EXPECT_EQ(activating->isActive_, false);
|
|
auto result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, false);
|
|
result = activating->StateProcess(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_StateBegin_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_StateBegin_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
disconnecting->StateBegin();
|
|
EXPECT_EQ(disconnecting->isActive_, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessConnectTimeout_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
|
|
disconnecting->ProcessDisconnectTimeout(event);
|
|
EXPECT_EQ(cellularMachine->IsInactiveState(), false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessConnectTimeout_002
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_002, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
|
|
disconnecting->ProcessDisconnectTimeout(event);
|
|
EXPECT_EQ(cellularMachine->IsInactiveState(), false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessRilAdapterHostDied_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
|
|
disconnecting->ProcessRilAdapterHostDied(event);
|
|
EXPECT_EQ(cellularMachine->IsInactiveState(), false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessRilDeactivateDataCall_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
EXPECT_NE(machine, nullptr);
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
|
|
disconnecting->ProcessRilDeactivateDataCall(event);
|
|
cellularMachine->IsInactiveState();
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessRilDeactivateDataCall_002
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_002, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
EXPECT_NE(machine, nullptr);
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
cellularMachine->TransitionTo(cellularMachine->defaultState_);
|
|
cellularMachine->stateMachineEventHandler_ = nullptr;
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
|
|
disconnecting->ProcessRilDeactivateDataCall(event);
|
|
cellularMachine->IsInactiveState();
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessRilDeactivateDataCall_003
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_003, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
EXPECT_NE(machine, nullptr);
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
cellularMachine->TransitionTo(cellularMachine->defaultState_);
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
|
|
event = nullptr;
|
|
disconnecting->ProcessRilDeactivateDataCall(event);
|
|
cellularMachine->IsInactiveState();
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessRilDeactivateDataCall_004
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_004, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
cellularMachine->connectId_ = 1;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 1;
|
|
radioResponseInfo->error = ErrType::ERR_GENERIC_FAILURE;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, radioResponseInfo);
|
|
disconnecting->ProcessRilDeactivateDataCall(event);
|
|
EXPECT_FALSE(cellularMachine->IsInactiveState());
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_StateProcess_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_DEACTIVATE_DATA_CALL);
|
|
bool result = disconnecting->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DISCONNECT_TIMEOUT_CHECK);
|
|
result = disconnecting->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_RIL_ADAPTER_HOST_DIED);
|
|
result = disconnecting->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT);
|
|
result = disconnecting->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
event = AppExecFwk::InnerEvent::Get(0);
|
|
result = disconnecting->StateProcess(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_StateProcess_002
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_002, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
cellularMachine = nullptr;
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_DEACTIVATE_DATA_CALL);
|
|
bool result = disconnecting->StateProcess(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number InactiveStateProcess_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, InactiveStateProcess_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto inactive = std::static_pointer_cast<Inactive>(cellularMachine->inActiveState_);
|
|
inactive->stateMachine_ = cellularMachine;
|
|
sptr<ApnHolder> apnHolder;
|
|
int32_t profileId = 0;
|
|
int32_t radioTechnology = 0;
|
|
bool nonTrafficUseOnly = false;
|
|
bool roamingState = false;
|
|
bool userDataRoaming = false;
|
|
std::shared_ptr<DataConnectionParams> dataConnectionParams = std::make_shared<DataConnectionParams>(apnHolder,
|
|
profileId, radioTechnology, nonTrafficUseOnly, roamingState, userDataRoaming);
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, dataConnectionParams);
|
|
bool result = inactive->StateProcess(event);
|
|
EXPECT_EQ(result, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessDisconnectTimeout_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessDisconnectTimeout_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
cellularMachine = nullptr;
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, 0);
|
|
disconnecting->ProcessDisconnectTimeout(event);
|
|
disconnecting->StateEnd();
|
|
EXPECT_EQ(disconnecting->isActive_, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Disconnecting_ProcessRilAdapterHostDied_002
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_002, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto disconnecting = std::static_pointer_cast<Disconnecting>(cellularMachine->disconnectingState_);
|
|
cellularMachine->inActiveState_ = nullptr;
|
|
disconnecting->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, 0);
|
|
disconnecting->ProcessRilAdapterHostDied(event);
|
|
EXPECT_EQ(cellularMachine->IsDisconnectingState(), false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilActivatePdpContextDone_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine = nullptr;
|
|
activating->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(0);
|
|
bool result = activating->RilActivatePdpContextDone(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilActivatePdpContextDone_002
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_002, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
|
|
setupDataCallResultInfo->flag = 2;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
|
|
bool result = activating->RilActivatePdpContextDone(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilActivatePdpContextDone_003
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_003, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
EXPECT_NE(machine, nullptr);
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
|
|
setupDataCallResultInfo->flag = 1;
|
|
setupDataCallResultInfo->reason = 1;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
|
|
activating->RilActivatePdpContextDone(event);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilActivatePdpContextDone_004
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_004, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
EXPECT_NE(machine, nullptr);
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
|
|
setupDataCallResultInfo->flag = 1;
|
|
setupDataCallResultInfo->reason = 0;
|
|
setupDataCallResultInfo->active = 0;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
|
|
activating->RilActivatePdpContextDone(event);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilActivatePdpContextDone_005
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_005, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
|
|
setupDataCallResultInfo->flag = 1;
|
|
setupDataCallResultInfo->reason = 0;
|
|
setupDataCallResultInfo->active = 1;
|
|
setupDataCallResultInfo->cid = 99;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
|
|
bool result = activating->RilActivatePdpContextDone(event);
|
|
EXPECT_EQ(result, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 12;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_002
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_002, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 1;
|
|
radioResponseInfo->error = ErrType::ERR_GENERIC_FAILURE;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_003
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_003, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 1;
|
|
radioResponseInfo->error = ErrType::ERR_INVALID_RESPONSE;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_004
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_004, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 1;
|
|
radioResponseInfo->error = ErrType::NONE;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, true);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_005
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_005, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine = nullptr;
|
|
activating->stateMachine_ = cellularMachine;
|
|
auto event = AppExecFwk::InnerEvent::Get(0);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Active_CellularDataStateMachine_001
|
|
* @tc.name test function branch
|
|
* @tc.desc Function test
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Active_CellularDataStateMachine_001, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto active = std::static_pointer_cast<Active>(cellularMachine->activeState_);
|
|
cellularMachine = nullptr;
|
|
active->stateMachine_ = cellularMachine;
|
|
active->StateBegin();
|
|
auto event = AppExecFwk::InnerEvent::Get(0);
|
|
bool result = active->ProcessDisconnectDone(event);
|
|
EXPECT_EQ(result, false);
|
|
result = active->ProcessDisconnectAllDone(event);
|
|
EXPECT_EQ(result, false);
|
|
result = active->ProcessLostConnection(event);
|
|
EXPECT_EQ(result, false);
|
|
result = active->ProcessLinkCapabilityChanged(event);
|
|
EXPECT_EQ(result, false);
|
|
result = active->ProcessDataConnectionRoamOn(event);
|
|
EXPECT_EQ(result, false);
|
|
active->RefreshConnectionBandwidths();
|
|
result = active->ProcessDataConnectionRoamOff(event);
|
|
EXPECT_EQ(result, false);
|
|
active->RefreshTcpBufferSizes();
|
|
result = active->ProcessDataConnectionVoiceCallStartedOrEnded(event);
|
|
EXPECT_EQ(result, false);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_006
|
|
* @tc.name test rilSetChdataErrCnt_ branch to trigger RestartRadio
|
|
* @tc.desc Function test - test RestartRadio is called when rilSetChdataErrCnt_ reaches 5 with error = 100
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_006, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
activating->rilSetChdataErrCnt_ = 4;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 1;
|
|
radioResponseInfo->error = ErrType::ERR_SET_CHDATA_FAIL;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, true);
|
|
EXPECT_EQ(activating->rilSetChdataErrCnt_, 0);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_007
|
|
* @tc.name test rilSetChdataErrCnt_ does not trigger RestartRadio when less than 5
|
|
* @tc.desc Function test - test RestartRadio is not called when rilSetChdataErrCnt_ is less than 5 with error=100
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_007, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
activating->rilSetChdataErrCnt_ = 3;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 1;
|
|
radioResponseInfo->error = ErrType::ERR_SET_CHDATA_FAIL;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, true);
|
|
EXPECT_EQ(activating->rilSetChdataErrCnt_, 4);
|
|
}
|
|
|
|
/**
|
|
* @tc.number Activating_RilErrorResponse_008
|
|
* @tc.name test non-RIL_ERR_SET_CHDATA error goes to else branch
|
|
* @tc.desc Function test - test non-100 error does not increment rilSetChdataErrCnt_
|
|
*/
|
|
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_008, Function | MediumTest | Level1)
|
|
{
|
|
if (cellularMachine == nullptr) {
|
|
std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
|
|
cellularMachine = machine->CreateCellularDataConnect(0);
|
|
cellularMachine->Init();
|
|
}
|
|
auto activating = std::static_pointer_cast<Activating>(cellularMachine->activatingState_);
|
|
cellularMachine->connectId_ = 1;
|
|
activating->stateMachine_ = cellularMachine;
|
|
activating->rilSetChdataErrCnt_ = 3;
|
|
std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
|
|
radioResponseInfo->flag = 1;
|
|
radioResponseInfo->error = ErrType::ERR_GENERIC_FAILURE;
|
|
auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
|
|
bool result = activating->RilErrorResponse(event);
|
|
EXPECT_EQ(result, true);
|
|
EXPECT_EQ(activating->rilSetChdataErrCnt_, 3);
|
|
}
|
|
|
|
} // namespace Telephony
|
|
} // namespace OHOS
|