218 lines
8.5 KiB
C++
218 lines
8.5 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 "HalTestTool.h"
|
|
#include "HalMakePtrTest.h"
|
|
#include "ILog.h"
|
|
#include <thread>
|
|
StatusCode HalCppTest::GetLedHals(std::vector<std::shared_ptr<VLedHal>> &ledHals)
|
|
{
|
|
LogInfo("HalCppTest::GetLedHals\n");
|
|
StatusCode code = GetLedHalsTrace(ledHals);
|
|
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
|
|
return HalCpp::GetLedHals(ledHals);
|
|
}
|
|
return code;
|
|
}
|
|
StatusCode HalCppTest::GetAllKeys(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
|
|
{
|
|
LogInfo("HalCppTest::GetAllKeys\n");
|
|
StatusCode code = GetAllKeysTrace(allKeys);
|
|
if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
|
|
return HalCpp::GetAllKeys(allKeys);
|
|
}
|
|
return code;
|
|
}
|
|
StatusCode HalCppTest::GetLedHalsTrace(std::vector<std::shared_ptr<VLedHal>> &ledHals)
|
|
{
|
|
LogInfo("HalCppTest::GetLedHalsTrace\n");
|
|
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
|
|
}
|
|
StatusCode HalCppTest::GetAllKeysTrace(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
|
|
{
|
|
LogInfo("HalCppTest::GetAllKeysTrace\n");
|
|
return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
|
|
}
|
|
KeyControlTest::KeyControlTest(const std::string &keyName) : mKeyName(keyName)
|
|
{
|
|
//
|
|
}
|
|
void KeyControlTest::SetKeyMonitor(std::shared_ptr<VKeyHalMonitor> &monitor)
|
|
{
|
|
//
|
|
mMonitor = monitor;
|
|
}
|
|
void KeyControlTest::CheckKeyStatus(void)
|
|
{
|
|
//
|
|
TimerKeyEventTrigger(KeyHalEvent::PRESSING);
|
|
}
|
|
void KeyControlTest::KeyEventTrigger(const std::string &keyName, const KeyEvent &event, const unsigned int &timeMs)
|
|
{
|
|
LogInfo("KeyEventTrigger keyName = %s, event = %s, time = %u\n", keyName.c_str(), PrintKeyEvent(event), timeMs);
|
|
KeyEventTriggerTrace(keyName, event, timeMs);
|
|
auto monitor = mMonitor.lock();
|
|
if (mMonitor.expired()) {
|
|
LogError("monitor is nullptr.\n");
|
|
return;
|
|
}
|
|
monitor->KeyEventHappened(keyName, static_cast<VirtualKeyEvent>(event), timeMs);
|
|
}
|
|
KeyControlMock::KeyControlMock(const std::string &keyName) : KeyControlTest(keyName)
|
|
{
|
|
//
|
|
}
|
|
void KeyControlMock::SetKeyEvent(const KeyHalEvent &event)
|
|
{
|
|
//
|
|
KeyHalEventTrigger(event);
|
|
}
|
|
bool KeyControlMock::SetKeyClick(const unsigned int &pressingTimeMs)
|
|
{
|
|
if (mMutex.try_lock()) {
|
|
auto keyClickThread = [=](std::shared_ptr<KeyControlMock> key) {
|
|
KeyEventHappendOnce(key, pressingTimeMs);
|
|
key->KeyHalEventTrigger(KeyHalEvent::PRESSING);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(pressingTimeMs));
|
|
key->KeyHalEventTrigger(KeyHalEvent::NOT_PRESSING);
|
|
mMutex.unlock();
|
|
};
|
|
std::shared_ptr<KeyControl> tmp = KeyControl::shared_from_this();
|
|
std::shared_ptr<KeyControlMock> key = std::dynamic_pointer_cast<KeyControlMock>(tmp);
|
|
std::thread clickThread = std::thread(keyClickThread, key);
|
|
clickThread.detach();
|
|
return true;
|
|
}
|
|
LogWarning("SetKeyClick failed, becase key was lock.\n");
|
|
return false;
|
|
}
|
|
void KeyControlMock::KeyEventHappendOnce(std::shared_ptr<KeyControlMock> &mock, const unsigned int &pressingTimeMs)
|
|
{
|
|
EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(_, _, _))
|
|
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
|
|
constexpr int CLICK_EVENT_HAPPENED_ONLY_ONCE = 1;
|
|
constexpr int HOLD_UP_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))));
|
|
EXPECT_CALL(*mock.get(), KeyEventTriggerTrace(mock->GetKeyName(), KeyEvent::HOLD_UP, _))
|
|
.Times(HOLD_UP_EVENT_HAPPENED_ONLY_ONCE)
|
|
.WillOnce(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
|
|
}
|
|
}
|
|
void HalTestTool::Init(void)
|
|
{
|
|
mHalMock = std::make_shared<HalCppMock>();
|
|
HalMockInit(mHalMock);
|
|
OverrideHalMakePtrObject(mHalMock);
|
|
}
|
|
void HalTestTool::UnInit(void)
|
|
{
|
|
mHalMock.reset();
|
|
CancelOverrideHalMakePtrObject();
|
|
}
|
|
void HalTestTool::SetAllKeysResult(std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
|
|
{
|
|
SetAllKeysResult(mHalMock, allKeys);
|
|
mAllKeys = allKeys;
|
|
}
|
|
void HalTestTool::SetKeyEvent(const std::string keyName, const KeyHalEvent &event)
|
|
{
|
|
std::shared_ptr<KeyControlMock> key = SearchKey(keyName);
|
|
if (!key) {
|
|
LogError("Can't set key event, key not found.\n");
|
|
return;
|
|
}
|
|
key->SetKeyEvent(event);
|
|
}
|
|
void HalTestTool::SetKeyClick(const std::string &keyName, const unsigned int &pressingTimeMs)
|
|
{
|
|
std::shared_ptr<KeyControlMock> key = SearchKey(keyName);
|
|
if (!key) {
|
|
LogError("Can't set key event, key not found.\n");
|
|
return;
|
|
}
|
|
if (key->SetKeyClick(pressingTimeMs)) {
|
|
// KeyEventHappendOnce(key, pressingTimeMs);
|
|
DeviceManagerNotice(keyName, pressingTimeMs);
|
|
}
|
|
}
|
|
void HalTestTool::KeyEventHappendOnce(std::shared_ptr<KeyControlMock> &mock, const unsigned int &pressingTimeMs)
|
|
{
|
|
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))));
|
|
}
|
|
}
|
|
void HalTestTool::SetAllKeysResult(std::shared_ptr<HalCppMock> &mock,
|
|
std::map<std::string, std::shared_ptr<VKeyHal>> &allKeys)
|
|
{
|
|
EXPECT_CALL(*mock.get(), GetAllKeysTrace(_))
|
|
.WillRepeatedly(DoAll(SetArgReferee<0>(allKeys), Return(CreateStatusCode(STATUS_CODE_OK))));
|
|
InitAllKeysMock(allKeys);
|
|
}
|
|
std::shared_ptr<KeyControlMock> 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;
|
|
std::shared_ptr<KeyControlMock> mock = std::dynamic_pointer_cast<KeyControlMock>(keyHal);
|
|
if (mock) {
|
|
InitKeysMock(mock);
|
|
}
|
|
else {
|
|
LogWarning("Invalid key mock.\n");
|
|
}
|
|
}
|
|
}
|
|
void HalTestTool::InitKeysMock(std::shared_ptr<KeyControlMock> &mock)
|
|
{
|
|
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<HalCppMock> &mock)
|
|
{
|
|
EXPECT_CALL(*mock.get(), GetLedHalsTrace(_))
|
|
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
|
|
EXPECT_CALL(*mock.get(), GetAllKeysTrace(_))
|
|
.WillRepeatedly(DoAll(Return(CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION))));
|
|
} |