mirror of
https://gitee.com/jiuyilian/embedded-framework.git
synced 2025-10-24 18:20:15 -04:00
1112 lines
47 KiB
C++
1112 lines
47 KiB
C++
/*
|
|
* Copyright (c) 2023 Fancy Code.
|
|
* 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.
|
|
*/
|
|
#include "McuAskBase.h"
|
|
#include "McuAskBaseTestTool.h"
|
|
#include "McuManagerMockTest.h"
|
|
#include <thread>
|
|
namespace McuManager_Mock_Test
|
|
{
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_GetIpcMission
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This test is an example that demonstrates how to obtain IpcMission data and add the business code after obtaining the
|
|
* data in the abstract interface.
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_GetIpcMission)
|
|
{
|
|
/**
|
|
* @brief The user needs to derive a subclass of McuAskBase and add the business code after obtaining data in the
|
|
* abstract interface.
|
|
*/
|
|
class McuAskTest : public McuAsk<IpcMission>, public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::BLOCK
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBase::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
LogInfo("GetIpcMission will block here.\n");
|
|
IMcuManager::GetInstance()->GetIpcMission(ask);
|
|
LogInfo("GetIpcMission finished.\n");
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_GetIpcMission2
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This test is an example that demonstrates how to obtain IpcMission data and add the business code after obtaining the
|
|
* data in the abstract interface.
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_GetIpcMission2)
|
|
{
|
|
/**
|
|
* @brief The user needs to derive a subclass of McuAskBase and add the business code after obtaining data in the
|
|
* abstract interface.
|
|
*/
|
|
class McuAskTest : public McuAsk<IpcMission>, public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::NOT_BLOCK
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBase::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
LogInfo("GetIpcMission will not block here.\n");
|
|
IMcuManager::GetInstance()->GetIpcMission(ask);
|
|
LogInfo("GetIpcMission finished.\n");
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendIpcMission
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This example demonstrates how to use a monitor to capture event information sent by an MCU. You must assign a value
|
|
* to the processing result (mDataReply member) and call the ReplyFinished function to complete the entire process.
|
|
*/
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 2;
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendIpcMission)
|
|
{
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
|
|
{
|
|
LogInfo("RecvIpcMissionEvent\n");
|
|
// std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
|
|
// ask->mDataReply = ASK_RESULT::SUCCEED;
|
|
recv->ReplyFinished(true);
|
|
// EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideAskIpcMission(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendHeartBeat
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This example demonstrates how to use a monitor to capture event information sent by an MCU. You must assign a value
|
|
* to the processing result (mDataReply member) and call the ReplyFinished function to complete the entire process.
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_OtherSideSendHeartBeat)
|
|
{
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvMcuHeartBeatEvent(std::shared_ptr<VMcuRecv> &recv) override
|
|
{
|
|
LogInfo("RecvMcuHeartBeatEvent\n");
|
|
// std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
|
|
// ask->mDataReply = ASK_RESULT::SUCCEED;
|
|
recv->ReplyFinished(true);
|
|
// EXPECT_EQ(TEST_SERIAL_NUMBER, recv->mSerialNumber);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideAskHeartBeat(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(3000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_CutOffPowerSupply
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_CutOffPowerSupply)
|
|
{
|
|
class McuAskTest : public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::UNRELATED, McuAskReply::NEED_NOT_REPLY)
|
|
{
|
|
} // using McuAskReply::NEED_NOT_REPLY
|
|
virtual ~McuAskTest() = default;
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
StatusCode code = IMcuManager::GetInstance()->CutOffPowerSupply(ask);
|
|
if (IsCodeOK(code) == true) {
|
|
LogInfo("Write data to mcu succeed.\n");
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_FeedWatchDog
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_FeedWatchDog)
|
|
{
|
|
class McuAskTest : public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::UNRELATED, McuAskReply::NEED_NOT_REPLY)
|
|
{
|
|
} // using McuAskReply::NEED_NOT_REPLY
|
|
virtual ~McuAskTest() = default;
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
StatusCode code = IMcuManager::GetInstance()->FeedWatchDog(ask);
|
|
if (IsCodeOK(code) == true) {
|
|
LogInfo("Write data to mcu succeed.\n");
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_SetFeedingCycleForWatchDog
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_SetFeedingCycleForWatchDog)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::BLOCK
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBase::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
StatusCode code = IMcuManager::GetInstance()->SetFeedingCycleForWatchDog(ask, 0, 0, 0);
|
|
if (IsCodeOK(code) == true) {
|
|
LogInfo("Write data to mcu succeed.\n");
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_SetDateTime
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_SetDateTime)
|
|
{
|
|
/**
|
|
* @brief The user needs to derive a subclass of McuAskBase and add the business code after obtaining data in the
|
|
* abstract interface.
|
|
*/
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::NOT_BLOCK
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBase::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
McuAskDateTime value(2014, 1, 15, 0, 0, 0);
|
|
IMcuManager::GetInstance()->SetDateTime(ask, value);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_SetPirSensitivity
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_SetPirSensitivity)
|
|
{
|
|
/**
|
|
* @brief The user needs to derive a subclass of McuAskBase and add the business code after obtaining data in the
|
|
* abstract interface.
|
|
*/
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::NOT_BLOCK
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBase::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
IMcuManager::GetInstance()->SetPirSensitivity(ask, 9);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_ContorlInfraredLight
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_ContorlInfraredLight)
|
|
{
|
|
/**
|
|
* @brief The user needs to derive a subclass of McuAskBase and add the business code after obtaining data in the
|
|
* abstract interface.
|
|
*/
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::NOT_BLOCK
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBase::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
IMcuManager::GetInstance()->ContorlInfraredLight(ask, ControlLight::TRUN_ON);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_EXAMPLE_GetPhotosensitivityValue
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_EXAMPLE_GetPhotosensitivityValue)
|
|
{
|
|
/**
|
|
* @brief The user needs to derive a subclass of McuAskBase and add the business code after obtaining data in the
|
|
* abstract interface.
|
|
*/
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBase
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBase(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::NOT_BLOCK
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBase::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
IMcuManager::GetInstance()->GetPhotosensitivityValue(ask);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_GetIpcMission
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_GetIpcMission)
|
|
{
|
|
class McuAskTest : public McuAsk<IpcMission>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
IMcuManager::GetInstance()->GetIpcMission(ask);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
/**
|
|
* @brief This use case demonstrates that only the serial port was opened and written successfully, and no data was
|
|
* read.
|
|
* Run Test:
|
|
* ../output_files/test/bin/McuManagerTest
|
|
* --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_GetIpcMission_1
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_GetIpcMission_1)
|
|
{
|
|
class McuAskTest : public McuAsk<IpcMission>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
McuManagerTestTool::MockMcuDeviceOpenSuccessButReadNothing(mLinuxTest);
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
IMcuManager::GetInstance()->GetIpcMission(ask);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_GetIpcMission
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_GetIpcMission2)
|
|
{
|
|
class McuAskTest : public McuAsk<IpcMission>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::NOT_BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
IMcuManager::GetInstance()->GetIpcMission(ask);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(3000));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_CutOffPowerSupply
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_CutOffPowerSupply)
|
|
{
|
|
class McuAskTest : public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest()
|
|
: McuAskBaseTestTool(McuAskBlock::UNRELATED,
|
|
McuAskReply::NEED_NOT_REPLY) // using McuAskReply::NEED_NOT_REPLY
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
StatusCode code = IMcuManager::GetInstance()->CutOffPowerSupply(ask);
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_FeedWatchDog
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_FeedWatchDog)
|
|
{
|
|
class McuAskTest : public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest()
|
|
: McuAskBaseTestTool(McuAskBlock::UNRELATED,
|
|
McuAskReply::NEED_NOT_REPLY) // using McuAskReply::NEED_NOT_REPLY
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
StatusCode code = IMcuManager::GetInstance()->FeedWatchDog(ask);
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_FeedWatchDogThread
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_FeedWatchDogThread)
|
|
{
|
|
IMcuManager::GetInstance()->Init();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
|
|
McuAskReply::NEED_REPLY) // using McuAskBlock::BLOCK,
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
StatusCode code = IMcuManager::GetInstance()->SetFeedingCycleForWatchDog(ask, 1, 1, 1);
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog2
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog2)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest()
|
|
: McuAskBaseTestTool(McuAskBlock::NOT_BLOCK,
|
|
McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
StatusCode code = IMcuManager::GetInstance()->SetFeedingCycleForWatchDog(ask, 1, 1, 1);
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrite
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_STRESS_MultiThreadWrite)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
|
|
McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask ASK_RESULT succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
class McuAskTest2 : public McuAsk<IpcMission>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest2() : McuAskBaseTestTool(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
} // using McuAskBlock::NOT_BLOCK
|
|
virtual ~McuAskTest2() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask IpcMission succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
auto threadTest1 = [](McuManagerMockTest *test) {
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
StatusCode code = IMcuManager::GetInstance()->SetFeedingCycleForWatchDog(ask, 1, 1, 1);
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
EXPECT_EQ(test->CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
};
|
|
auto threadTest2 = [](McuManagerMockTest *test) {
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest2>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
IMcuManager::GetInstance()->GetIpcMission(ask);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
EXPECT_EQ(test->CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::thread thread_1 = std::thread(threadTest1, this);
|
|
std::thread thread_2 = std::thread(threadTest2, this);
|
|
if (thread_1.joinable()) {
|
|
thread_1.join();
|
|
}
|
|
if (thread_2.joinable()) {
|
|
thread_2.join();
|
|
}
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_SetDataTime
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetDataTime)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
|
|
McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
McuAskDateTime value(2014, 1, 15, 0, 0, 0);
|
|
StatusCode code = IMcuManager::GetInstance()->SetDateTime(ask, value);
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_SetDataTime2
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetDataTime2)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest()
|
|
: McuAskBaseTestTool(McuAskBlock::NOT_BLOCK,
|
|
McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
McuAskDateTime value(2014, 1, 15, 0, 0, 0);
|
|
StatusCode code = IMcuManager::GetInstance()->SetDateTime(ask, value);
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_SetPirSensitivity
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetPirSensitivity)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK,
|
|
McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
StatusCode code = IMcuManager::GetInstance()->SetPirSensitivity(ask, 1);
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_SetPirSensitivity2
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_SetPirSensitivity2)
|
|
{
|
|
class McuAskTest : public McuAsk<ASK_RESULT>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest()
|
|
: McuAskBaseTestTool(McuAskBlock::NOT_BLOCK,
|
|
McuAskReply::NEED_REPLY) // using McuAskBlock::NOT_BLOCK
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
// Do something here.
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDefaultFeatures(testTool);
|
|
StatusCode code = IMcuManager::GetInstance()->SetPirSensitivity(ask, 2);
|
|
EXPECT_EQ(code.mStatusCode, STATUS_CODE_OK); // STATUS_CODE_OK means write data to mcu succeed.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_GetIpcMissionFailed
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_GetIpcMissionFailed)
|
|
{
|
|
class McuAskTest : public McuAsk<IpcMission>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
}
|
|
virtual ~McuAskTest() = default;
|
|
void ReplyFinished(const bool result) override
|
|
{
|
|
McuAskBaseTestTool::ReplyFinished(result);
|
|
if (result) {
|
|
LogInfo("Ask data succeed, mDataReply = %d.\n", static_cast<int>(mDataReply));
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
McuManagerTestTool::MockMcuDeviceOpenFailed(mLinuxTest);
|
|
IMcuManager::GetInstance()->Init();
|
|
std::shared_ptr<VMcuAsk> ask = std::make_shared<McuAskTest>();
|
|
std::shared_ptr<McuAskBaseTestTool> testTool = std::dynamic_pointer_cast<McuAskBaseTestTool>(ask);
|
|
testTool->McuAskDoNothing(testTool);
|
|
testTool->NoNeedToBlocking(testTool);
|
|
IMcuManager::GetInstance()->GetIpcMission(ask);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
EXPECT_EQ(CheckAskExist(ask), false); // Ensure that the request has been processed and deleted.
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
|
|
{
|
|
LogInfo("RecvIpcMissionEvent\n");
|
|
std::shared_ptr<McuRecv<unsigned char>> recvData = std::dynamic_pointer_cast<McuRecv<unsigned char>>(recv);
|
|
recv->ReplyFinished(true);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideAskIpcMission(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This test case simulates the state machine receiving serial port data before it is fully started. At this point, the
|
|
* serial port data should be cached until the state machine starts and registers the serial port monitor, and reports
|
|
* the serial port data when registering the serial port monitor.
|
|
* Run: ../output_files/test/bin/McuManagerTest
|
|
* --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission2
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission2)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
|
|
{
|
|
LogInfo("RecvIpcMissionEvent\n");
|
|
std::shared_ptr<McuRecv<unsigned char>> recvData = std::dynamic_pointer_cast<McuRecv<unsigned char>>(recv);
|
|
recv->ReplyFinished(true);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideAskIpcMission(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetIntervalStart
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetIntervalStart)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvGetIntervalStartEvent(std::shared_ptr<VMcuRecv> &recv) override
|
|
{
|
|
LogInfo("RecvGetIntervalStartEvent\n");
|
|
std::shared_ptr<McuRecv<McuGetIntervalStart>> recvData =
|
|
std::dynamic_pointer_cast<McuRecv<McuGetIntervalStart>>(recv);
|
|
EXPECT_NE(recvData, nullptr) << "recvData is not McuGetIntervalStart.";
|
|
if (recvData) {
|
|
recvData->mDataRecvReply.mHour = 10;
|
|
recvData->mDataRecvReply.mMin = 10;
|
|
recvData->mDataRecvReply.mSecond = 10;
|
|
recv->ReplyFinished(true);
|
|
return;
|
|
}
|
|
recv->ReplyFinished(false);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideGetIntervalStart(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This test case simulates the state machine receiving serial port data before it is fully started. At this point, the
|
|
* serial port data should be cached until the state machine starts and registers the serial port monitor, and reports
|
|
* the serial port data when registering the serial port monitor.
|
|
* Run: ../output_files/test/bin/McuManagerTest
|
|
* --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetIntervalStart2
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetIntervalStart2)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvGetIntervalStartEvent(std::shared_ptr<VMcuRecv> &recv) override
|
|
{
|
|
LogInfo("RecvGetIntervalStartEvent\n");
|
|
std::shared_ptr<McuRecv<McuGetIntervalStart>> recvData =
|
|
std::dynamic_pointer_cast<McuRecv<McuGetIntervalStart>>(recv);
|
|
EXPECT_NE(recvData, nullptr) << "recvData is not McuGetIntervalStart.";
|
|
if (recvData) {
|
|
recvData->mDataRecvReply.mHour = 10;
|
|
recvData->mDataRecvReply.mMin = 10;
|
|
recvData->mDataRecvReply.mSecond = 10;
|
|
recv->ReplyFinished(true);
|
|
return;
|
|
}
|
|
recv->ReplyFinished(false);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideGetIntervalStart(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetDateTime
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetDateTime)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvGetDateTime(std::shared_ptr<VMcuRecv> &recv) override
|
|
{
|
|
LogInfo("RecvGetDateTime\n");
|
|
std::shared_ptr<McuRecv<McuReplyDateTime>> recvData =
|
|
std::dynamic_pointer_cast<McuRecv<McuReplyDateTime>>(recv);
|
|
EXPECT_NE(recvData, nullptr) << "recvData is not McuReplyDateTime.";
|
|
if (recvData) {
|
|
recvData->mDataRecvReply.mYear = 2024;
|
|
recvData->mDataRecvReply.mMon = 10;
|
|
recvData->mDataRecvReply.mDay = 10;
|
|
recvData->mDataRecvReply.mHour = 10;
|
|
recvData->mDataRecvReply.mMin = 10;
|
|
recvData->mDataRecvReply.mSecond = 10;
|
|
recv->ReplyFinished(true);
|
|
return;
|
|
}
|
|
recv->ReplyFinished(false);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideGetDateTime(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This test case simulates the state machine receiving serial port data before it is fully started. At this point, the
|
|
* serial port data should be cached until the state machine starts and registers the serial port monitor, and reports
|
|
* the serial port data when registering the serial port monitor.
|
|
* Run: ../output_files/test/bin/McuManagerTest
|
|
* --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetDateTime2
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetDateTime2)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvGetDateTime(std::shared_ptr<VMcuRecv> &recv) override
|
|
{
|
|
LogInfo("RecvGetDateTime\n");
|
|
std::shared_ptr<McuRecv<McuReplyDateTime>> recvData =
|
|
std::dynamic_pointer_cast<McuRecv<McuReplyDateTime>>(recv);
|
|
EXPECT_NE(recvData, nullptr) << "recvData is not McuReplyDateTime.";
|
|
if (recvData) {
|
|
recvData->mDataRecvReply.mYear = 2024;
|
|
recvData->mDataRecvReply.mMon = 10;
|
|
recvData->mDataRecvReply.mDay = 10;
|
|
recvData->mDataRecvReply.mHour = 10;
|
|
recvData->mDataRecvReply.mMin = 10;
|
|
recvData->mDataRecvReply.mSecond = 10;
|
|
recv->ReplyFinished(true);
|
|
return;
|
|
}
|
|
recv->ReplyFinished(false);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideGetDateTime(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetPirSensitivity
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetPirSensitivity)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvGetPirSensitivity(std::shared_ptr<VMcuRecv> &recv) override
|
|
{
|
|
LogInfo("RecvGetPirSensitivity\n");
|
|
std::shared_ptr<McuRecv<McuGetPirSensitivity>> recvData =
|
|
std::dynamic_pointer_cast<McuRecv<McuGetPirSensitivity>>(recv);
|
|
EXPECT_NE(recvData, nullptr) << "recvData is not McuGetPirSensitivity.";
|
|
if (recvData) {
|
|
recvData->mDataRecvReply.mSensitivity = 9;
|
|
recv->ReplyFinished(true);
|
|
return;
|
|
}
|
|
recv->ReplyFinished(false);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideGetPriSensitivity(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
/**
|
|
* @brief Construct a new test f object
|
|
* This test case simulates the state machine receiving serial port data before it is fully started. At this point, the
|
|
* serial port data should be cached until the state machine starts and registers the serial port monitor, and reports
|
|
* the serial port data when registering the serial port monitor.
|
|
* Run: ../output_files/test/bin/McuManagerTest
|
|
* --gtest_filter=McuManagerMockTest.HS_INTEGRATION_McuManager_AUTO_OtherSideGetPirSensitivity2
|
|
*/
|
|
TEST_F(McuManagerMockTest, HS_INTEGRATION_McuManager_AUTO_OtherSideGetPirSensitivity2)
|
|
{
|
|
constexpr unsigned int TEST_SERIAL_NUMBER = 99;
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvGetPirSensitivity(std::shared_ptr<VMcuRecv> &recv) override
|
|
{
|
|
LogInfo("RecvGetPirSensitivity\n");
|
|
std::shared_ptr<McuRecv<McuGetPirSensitivity>> recvData =
|
|
std::dynamic_pointer_cast<McuRecv<McuGetPirSensitivity>>(recv);
|
|
EXPECT_NE(recvData, nullptr) << "recvData is not McuGetPirSensitivity.";
|
|
if (recvData) {
|
|
recvData->mDataRecvReply.mSensitivity = 9;
|
|
recv->ReplyFinished(true);
|
|
return;
|
|
}
|
|
recv->ReplyFinished(false);
|
|
}
|
|
};
|
|
IMcuManager::GetInstance()->Init();
|
|
MockOtherSideGetPriSensitivity(mLinuxTest, TEST_SERIAL_NUMBER);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
std::shared_ptr<VMcuMonitor> monitor = std::make_shared<MonitorTest>();
|
|
IMcuManager::GetInstance()->SetMcuMonitor(monitor);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
|
|
IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
} // namespace McuManager_Mock_Test
|