mirror of
https://gitee.com/jiuyilian/embedded-framework.git
synced 2025-01-06 10:16:51 -05:00
254 lines
10 KiB
C++
254 lines
10 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 "ILog.h"
|
|
#include "IMcuManager.h"
|
|
#include "McuAskBase.h"
|
|
#include "McuAskBaseTestTool.h"
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
#include <thread>
|
|
namespace McuManagerTest
|
|
{
|
|
class McuManagerTest : public testing::Test
|
|
{
|
|
public:
|
|
McuManagerTest()
|
|
{
|
|
}
|
|
virtual ~McuManagerTest()
|
|
{
|
|
}
|
|
static void SetUpTestCase()
|
|
{
|
|
CreateLogModule();
|
|
ILogInit(LOG_INSTANCE_TYPE_END);
|
|
}
|
|
static void TearDownTestCase()
|
|
{
|
|
ILogUnInit();
|
|
}
|
|
virtual void SetUp()
|
|
{
|
|
CreateMcuManager();
|
|
IMcuManager::GetInstance()->Init();
|
|
}
|
|
virtual void TearDown()
|
|
{
|
|
IMcuManager::GetInstance()->UnInit();
|
|
DestroyMcuManager();
|
|
}
|
|
};
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_GetIpcMission
|
|
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_GetIpcMission)
|
|
{
|
|
class McuAskTest : public McuAsk<IpcMission>, public McuAskBaseTestTool
|
|
{
|
|
public:
|
|
McuAskTest() : McuAskBaseTestTool(McuAskBlock::BLOCK, McuAskReply::NEED_REPLY)
|
|
{
|
|
mDataReply = IpcMission::END;
|
|
}
|
|
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.
|
|
EXPECT_GT(static_cast<int>(mDataReply), 0);
|
|
EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(IpcMission::END));
|
|
}
|
|
else {
|
|
LogError("Ask data falied.\n");
|
|
}
|
|
}
|
|
};
|
|
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));
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission
|
|
TEST_F(McuManagerTest, RH_INTEGRATION_McuManager_AUTO_OtherSideSendIpcMission)
|
|
{
|
|
class MonitorTest : public VMcuMonitor
|
|
{
|
|
public:
|
|
MonitorTest() = default;
|
|
virtual ~MonitorTest() = default;
|
|
void RecvIpcMissionEvent(std::shared_ptr<VMcuRecv> &recv, const IpcMission &mission) override
|
|
{
|
|
LogInfo("RecvIpcMissionEvent %s\n", IMcuManager::GetInstance()->PrintIpcMissionString(mission));
|
|
std::shared_ptr<McuAsk<ASK_RESULT>> ask = std::dynamic_pointer_cast<McuAsk<ASK_RESULT>>(recv);
|
|
ask->mDataReply = ASK_RESULT::SUCCEED;
|
|
recv->ReplyFinished(true);
|
|
}
|
|
};
|
|
// IMcuManager::GetInstance()->Init();
|
|
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=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_CutOffPowerSupply
|
|
TEST_F(McuManagerTest, RH_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(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=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetFeedingCycleForWatchDog
|
|
TEST_F(McuManagerTest, RH_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));
|
|
EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(ASK_RESULT::SUCCEED));
|
|
}
|
|
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));
|
|
// IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_FeedWatchDog
|
|
TEST_F(McuManagerTest, RH_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(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=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetDataTime
|
|
TEST_F(McuManagerTest, RH_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));
|
|
EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(ASK_RESULT::SUCCEED));
|
|
}
|
|
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));
|
|
// IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
// ../output_files/test/bin/McuManagerTest
|
|
// --gtest_filter=McuManagerTest.RH_INTEGRATION_McuManager_AUTO_SetPirSensitivity
|
|
TEST_F(McuManagerTest, RH_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));
|
|
EXPECT_LT(static_cast<int>(mDataReply), static_cast<int>(ASK_RESULT::SUCCEED));
|
|
}
|
|
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));
|
|
// IMcuManager::GetInstance()->UnInit();
|
|
}
|
|
} // namespace McuManagerTest
|