Germany/hunting
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity
cb5c52bae8
hunting/test/hal/tool/src/HalTestTool.cpp
Fancy code cb5c52bae8 Improve:sd card foramt when abnormal.
2024-07-22 10:24:54 +08:00

413 lines
16 KiB
C++
Raw Blame History

/*
* 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 "HalTestTool.h"
#include "CameraHalMock.h"
#include "GtestUsing.h"
#include "HalCppMock.h"
#include "HalMakePtr.h"
#include "HalMakePtrTest.h"
#include "IHalCpp.h"
#include "ILog.h"
#include "KeyControl.h"
#include "KeyControlMock.h"
#include "LedControl.h"
#include "LedControlMock.h"
#include "LinuxApiMock.h"
#include "SdCardHalMock.h"
#include "StatusCode.h"
#include "WifiHalMock.h"
#include <gmock/gmock-spec-builders.h>
#include <map>
#include <memory>
#include <string>
#include <vector>
void HalTestTool::Init(void)
{
mHalMock = std::make_shared<HalCppMock>();
mSdCardHal = std::make_shared<SdCardHalMock>();
HalMockInit(mHalMock);
// TODO: 初始化mSdCardHal
std::shared_ptr<HalCppMock> halMock = std::dynamic_pointer_cast<HalCppMock>(mHalMock);
std::shared_ptr<SdCardHalMock> sdCardHalMock = std::dynamic_pointer_cast<SdCardHalMock>(mSdCardHal);
OverrideHalMakePtrObject(halMock, sdCardHalMock);
}
void HalTestTool::InitSdCardHal(std::shared_ptr<LinuxTest> &mock)
{
std::shared_ptr<SdCardHalMock> sdCardHal = std::dynamic_pointer_cast<SdCardHalMock>(mSdCardHal);
if (nullptr == sdCardHal) {
LogError("SdCardHalMock is null.\n");
return;
}
sdCardHal->SetLinuxTest(mock);
}
void HalTestTool::UnInit(void)
{
mHalMock.reset();
CancelOverrideHalMakePtrObject();
mAllKeys.clear();
mAllLeds.clear();
}
void HalTestTool::SetAllKeysResult(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
{
std::shared_ptr<IHalCpp> halMock = mHalMock;
SetAllKeysResult(halMock, allKeys);
mAllKeys = allKeys;
}
void HalTestTool::SetAllLedsResult(std::map<std::string, std::shared_ptr<VLedHal>> &allLeds)
{
std::shared_ptr<IHalCpp> halMock = mHalMock;
SetAllLedsResult(halMock, allLeds);
mAllLeds = allLeds;
}
void HalTestTool::SetAllCamerasResult(std::map<CameraType, std::shared_ptr<VCameraHal>> &allCameras)
{
std::shared_ptr<IHalCpp> halMock = mHalMock;
SetAllCamerasResult(halMock, allCameras);
mAllCameras = allCameras;
}
void HalTestTool::MockKeyClick(const std::string &keyName, const unsigned int &pressingTimeMs)
{
std::shared_ptr<VKeyHal> key = SearchKey(keyName);
if (!key) {
LogError("Can't mock key event, key not found.\n");
return;
}
std::shared_ptr<KeyControlMock> keyMock = std::dynamic_pointer_cast<KeyControlMock>(key);
if (keyMock) {
if (keyMock->MockKeyClick(pressingTimeMs)) {
DeviceManagerNotice(keyName, pressingTimeMs);
}
}
else {
LogWarning("Key mock error.\n");
}
}
void HalTestTool::SetLedStateExpectations(const std::string &ledName, const LedState &state,
const unsigned int &aliveTimeMs, const unsigned int &blinkTimeMs)
{
std::shared_ptr<VLedHal> &led = SearchLed(ledName);
// if (!led) {
// LogError("Can't set led state, led not found.\n");
// return;
// }
// std::shared_ptr<LedControlMock> ledMock = std::dynamic_pointer_cast<LedControlMock>(led);
// if (ledMock) {
// LedControlMock::SetLedStateMock(ledMock, state, aliveTimeMs, blinkTimeMs);
// }
// else {
// LogWarning("led mock error.\n");
// }
LedControlMock::SetLedStateMock(led, state, aliveTimeMs, blinkTimeMs);
}
void HalTestTool::MockReportCameraEvent(const std::string &fileName, const CameraType &cameraType)
{
std::shared_ptr<VCameraHal> camera = SearchCamera(cameraType);
if (!camera) {
LogError("Can't mock camera event, camera not found.\n");
return;
}
std::shared_ptr<CameraHalMock> cameraMock = std::dynamic_pointer_cast<CameraHalMock>(camera);
if (cameraMock) {
CameraReportEvent report(fileName, cameraType);
cameraMock->MockReportCameraEvent(report);
}
else {
LogWarning("camera mock error.\n");
}
}
void HalTestTool::DeviceManagerNotice(const std::string &keyName, const unsigned int &pressingTimeMs)
{
}
void HalTestTool::KeyEventHappendOnce(std::shared_ptr<VKeyHal> &vMock, const unsigned int &pressingTimeMs)
{
std::shared_ptr<KeyControlMock> mock = std::dynamic_pointer_cast<KeyControlMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(_, _, _))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
constexpr int CLICK_EVENT_HAPPENED_ONLY_ONCE = 1;
if (KEY_ACTION_SHORT_CLICK <= pressingTimeMs && pressingTimeMs < KEY_ACTION_HOLD_DWON) {
EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(mock->GetKeyName(), KeyEvent::SHORT_CLICK, _))
.Times(CLICK_EVENT_HAPPENED_ONLY_ONCE)
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
if (KEY_ACTION_HOLD_DWON <= pressingTimeMs) {
EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(mock->GetKeyName(), KeyEvent::HOLD_DOWN, _))
.Times(AtLeast(1))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
}
std::shared_ptr<VKeyHal> HalTestTool::SearchKey(const std::string &keyName)
{
std::shared_ptr<KeyControlMock> mock;
std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
iter = mAllKeys.find(keyName);
if (iter != mAllKeys.end()) {
mock = std::dynamic_pointer_cast<KeyControlMock>(mAllKeys[keyName]);
}
else {
LogWarning("Can't found the key control.\n");
}
return mock;
}
void HalTestTool::InitAllKeysMock(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
{
std::map<std::string, std::shared_ptr<VKeyHal>>::iterator iter;
for (iter = allKeys.begin(); iter != allKeys.end(); ++iter) {
std::shared_ptr<VKeyHal> keyHal = iter->second;
InitKeysMock(keyHal);
}
}
void HalTestTool::InitKeysMock(std::shared_ptr<VKeyHal> &vMock)
{
std::shared_ptr<KeyControlMock> mock = std::dynamic_pointer_cast<KeyControlMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
constexpr int KEY_SHOULD_NOT_TRIGGER_WHEN_NOBODY_SET_KEY_RESULT = 0;
EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(_, _, _)).Times(KEY_SHOULD_NOT_TRIGGER_WHEN_NOBODY_SET_KEY_RESULT);
}
void HalTestTool::HalMockInit(std::shared_ptr<IHalCpp> &vMock)
{
std::shared_ptr<HalCppMock> mock = std::dynamic_pointer_cast<HalCppMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
EXPECT_CALL(*mock.get(), GetAllLedsTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
EXPECT_CALL(*mock.get(), GetAllKeysTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
std::shared_ptr<VWifiHal> wifiHal = std::make_shared<WifiHalMock>();
std::shared_ptr<WifiHalMock> wifiHalMock = std::dynamic_pointer_cast<WifiHalMock>(wifiHal);
EXPECT_CALL(*wifiHalMock.get(), OpenApMode()).WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_OK))));
EXPECT_CALL(*wifiHalMock.get(), PowerOn()).WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_OK))));
EXPECT_CALL(*wifiHalMock.get(), PowerOff()).WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_OK))));
EXPECT_CALL(*mock.get(), GetWifiHalTrace(_))
.WillRepeatedly(DoAll(SetArgReferee<0>(wifiHal), Return(CreateStatusCode(STATUS_CODE_OK))));
EXPECT_CALL(*mock.get(), GetCameraHalTrace(_))
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
void HalTestTool::SetAllKeysResult(std::shared_ptr<IHalCpp> &vMock,
std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
{
std::shared_ptr<HalCppMock> mock = std::dynamic_pointer_cast<HalCppMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
// EXPECT_CALL(*mock.get(), GetAllKeysTrace(_))
// .WillRepeatedly(DoAll(SetArgReferee<0>(allKeys), Return(CreateStatusCode(STATUS_CODE_OK))));
// InitAllKeysMock(allKeys);
std::vector<std::shared_ptr<VKeyControl>> keysMock;
std::shared_ptr<HalMakePtr> impl = HalMakePtr::GetInstance();
std::shared_ptr<HalMakePtrTest> test = std::dynamic_pointer_cast<HalMakePtrTest>(impl);
if (test) {
for (auto &key : allKeys) {
std::shared_ptr<KeyControlMock> keyMock = std::dynamic_pointer_cast<KeyControlMock>(key.second);
if (keyMock) {
keysMock.push_back(keyMock);
LogInfo("Create key mock. name = %s\n", keyMock->GetKeyName().c_str());
}
else {
LogWarning("Can't create key mock.\n");
}
}
test->mKeysMock = keysMock;
LogInfo("Create all keys mock. size = %d\n", keysMock.size());
}
}
void HalTestTool::SetAllLedsResult(std::shared_ptr<IHalCpp> &vMock,
std::map<std::string, std::shared_ptr<VLedHal>> &allLeds)
{
std::shared_ptr<HalCppMock> mock = std::dynamic_pointer_cast<HalCppMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
/**
* @brief
* Note: The SetArgReference function cannot be used here, as it will prevent the smart pointer from being released
* within the TEST range, resulting in an error only being reported after all test cases have finished running.
* Can't use:
* EXPECT_CALL(*mock.get(), GetAllLedsTrace(_))
* .WillRepeatedly(DoAll(SetArgReferee<0>(allLeds), Return(CreateStatusCode(STATUS_CODE_OK))));
*/
auto getAllLeds = [=, &allLeds](std::map<std::string, std::shared_ptr<VLedHal>> &setAllLeds) {
setAllLeds = allLeds;
};
EXPECT_CALL(*mock.get(), GetAllLedsTrace(_))
.WillRepeatedly(DoAll(WithArgs<0>(Invoke(getAllLeds)), Return(CreateStatusCode(STATUS_CODE_OK))));
InitAllLedsMock(allLeds);
}
std::shared_ptr<VLedHal> &HalTestTool::SearchLed(const std::string &ledName)
{
static std::shared_ptr<VLedHal> noLed = std::make_shared<VLedHal>();
std::shared_ptr<LedControlMock> mock;
std::map<std::string, std::shared_ptr<VLedHal>>::iterator iter;
iter = mAllLeds.find(ledName);
if (iter != mAllLeds.end()) {
// mock = std::dynamic_pointer_cast<LedControlMock>(mAllLeds[ledName]);
std::shared_ptr<VLedHal> &existLed = mAllLeds[ledName];
return existLed;
}
LogWarning("Can't found the led control.\n");
return noLed;
}
void HalTestTool::InitAllLedsMock(std::map<std::string, std::shared_ptr<VLedHal>> &allLeds)
{
std::map<std::string, std::shared_ptr<VLedHal>>::iterator iter;
for (iter = allLeds.begin(); iter != allLeds.end(); ++iter) {
std::shared_ptr<VLedHal> ledHal = iter->second;
InitLedsMock(ledHal);
}
}
void HalTestTool::InitLedsMock(std::shared_ptr<VLedHal> &vMock)
{
std::shared_ptr<LedControlMock> mock = std::dynamic_pointer_cast<LedControlMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
// constexpr int LED_SHOULD_NOT_BE_CONTROLED_WHEN_NOBODY_CONTROL_IT = 0;
EXPECT_CALL(*mock.get(), SetLedStateTrace(_))
.Times(AnyNumber())
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_OK))));
}
void HalTestTool::SetAllCamerasResult(std::shared_ptr<IHalCpp> &vMock,
std::map<CameraType, std::shared_ptr<VCameraHal>> &allCameras)
{
std::shared_ptr<HalCppMock> mock = std::dynamic_pointer_cast<HalCppMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
/**
* @brief
* Note: The SetArgReference function cannot be used here, as it will prevent the smart pointer from being released
* within the TEST range, resulting in an error only being reported after all test cases have finished running.
* Can't use:
* EXPECT_CALL(*mock.get(), GetCameraHalTrace(_))
* .WillRepeatedly(DoAll(SetArgReferee<0>(allCameras), Return(CreateStatusCode(STATUS_CODE_OK))));
*/
auto getAllCameras = [=, &allCameras](std::map<CameraType, std::shared_ptr<VCameraHal>> &setAllCameras) {
setAllCameras = allCameras;
};
EXPECT_CALL(*mock.get(), GetCameraHalTrace(_))
.WillRepeatedly(DoAll(WithArgs<0>(Invoke(getAllCameras)), Return(CreateStatusCode(STATUS_CODE_OK))));
InitAllCamerasMock(allCameras);
}
std::shared_ptr<VCameraHal> HalTestTool::SearchCamera(const CameraType &cameraType)
{
std::shared_ptr<CameraHalMock> mock;
std::map<CameraType, std::shared_ptr<VCameraHal>>::iterator iter;
iter = mAllCameras.find(cameraType);
if (iter != mAllCameras.end()) {
mock = std::dynamic_pointer_cast<CameraHalMock>(mAllCameras[cameraType]);
}
else {
LogWarning("Can't found the camera control.\n");
}
return mock;
}
void HalTestTool::InitAllCamerasMock(std::map<CameraType, std::shared_ptr<VCameraHal>> &allCameras)
{
std::map<CameraType, std::shared_ptr<VCameraHal>>::iterator iter;
for (iter = allCameras.begin(); iter != allCameras.end(); ++iter) {
std::shared_ptr<VCameraHal> cameraHal = iter->second;
InitCamerasMock(cameraHal);
}
}
void HalTestTool::InitCamerasMock(std::shared_ptr<VCameraHal> &vMock)
{
std::shared_ptr<CameraHalMock> mock = std::dynamic_pointer_cast<CameraHalMock>(vMock);
if (!mock) {
LogError("vMock error.\n");
return;
}
constexpr int USER_SHOULD_SET_CAMERA_MONITER = 1;
// constexpr int SINGLE_TASK_DEFAULT_TIMES = 0;
EXPECT_CALL(*mock.get(), SetCameraMonitorTrace(_)).Times(USER_SHOULD_SET_CAMERA_MONITER);
EXPECT_CALL(*mock.get(), StartSingleTaskTrace(_))
.Times(AnyNumber())
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
}
void HalTestTool::MockSdCardRemove(std::shared_ptr<LinuxTest> &mock)
{
std::shared_ptr<SdCardHalMock> sdCardHal = std::dynamic_pointer_cast<SdCardHalMock>(mSdCardHal);
if (nullptr == sdCardHal) {
LogError("SdCardHalMock is null.\n");
return;
}
sdCardHal->MockSdCardRemove(mock);
}
void HalTestTool::MockSdCardInsert(std::shared_ptr<LinuxTest> &mock)
{
std::shared_ptr<SdCardHalMock> sdCardHal = std::dynamic_pointer_cast<SdCardHalMock>(mSdCardHal);
if (nullptr == sdCardHal) {
LogError("SdCardHalMock is null.\n");
return;
}
sdCardHal->MockSdCardInsert(mock);
}
void HalTestTool::MockSdCardFormatReturn(std::shared_ptr<LinuxTest> &mock, const int &systemResult)
{
std::shared_ptr<SdCardHalMock> sdCardHal = std::dynamic_pointer_cast<SdCardHalMock>(mSdCardHal);
if (nullptr == sdCardHal) {
LogError("SdCardHalMock is null.\n");
return;
}
sdCardHal->MockSdCardFormatResult(mock, systemResult);
}
void HalTestTool::MockSdCardAbnormal(std::shared_ptr<LinuxTest> &mock)
{
std::shared_ptr<SdCardHalMock> sdCardHal = std::dynamic_pointer_cast<SdCardHalMock>(mSdCardHal);
if (nullptr == sdCardHal) {
LogError("SdCardHalMock is null.\n");
return;
}
sdCardHal->MockSdCardAbnormal(mock);
}
std::shared_ptr<VKeyHal> HalTestTool::MakeKeyHalTest(const std::string &keyName)
{
std::shared_ptr<VKeyHal> key = std::make_shared<KeyControlMock>(keyName);
std::dynamic_pointer_cast<KeyControlMock>(key)->InitKeyControlMock();
return key;
}
std::shared_ptr<VLedHal> HalTestTool::MakeLedHalTest(const std::string &ledName)
{
std::shared_ptr<VLedHal> led = std::make_shared<LedControlMock>(ledName);
return led;
}
std::shared_ptr<VCameraHal> HalTestTool::MakeCameraHalTest(const CameraType &type)
{
std::shared_ptr<VCameraHal> camera = HalMakePtrTest::GetInstance()->CreateCameraHal(type);
return camera;
}
void HalTestTool::DestroyCameraHalTest(std::map<CameraType, std::shared_ptr<VCameraHal>> &allCamerasMock)
{
for (const auto &camera : allCamerasMock) {
std::shared_ptr<CameraHalMock> impl = std::dynamic_pointer_cast<CameraHalMock>(camera.second);
if (impl) {
impl->UnInit();
}
else {
LogError("impl is null.\n");
}
}
}
Reference in New Issue View Git Blame Copy Permalink