embedded-framework/test/hal/tool/src/HalTestTool.cpp

/*
 * 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 "KeyControlMock.h"
#include <thread>
StatusCode HalCppTest::GetAllLeds(std::map<std::string, std::shared_ptr<VLedHal>> &allLeds)
{
    LogInfo("HalCppTest::GetAllLeds\n");
    StatusCode code = GetAllLedsTrace(allLeds);
    if (StatusCodeEqual(code, "STATUS_CODE_VIRTUAL_FUNCTION")) {
        return HalCpp::GetAllLeds(allLeds);
    }
    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::GetAllLedsTrace(std::map<std::string, std::shared_ptr<VLedHal>> &allLeds)
{
    LogInfo("HalCppTest::GetAllLedsTrace\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);
}
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<VKeyHal> key = SearchKey(keyName);
    if (!key) {
        LogError("Can't set key event, key not found.\n");
        return;
    }
    std::shared_ptr<KeyControlMock> keyMock = std::dynamic_pointer_cast<KeyControlMock>(key);
    if (keyMock) {
        keyMock->SetKeyEvent(event);
    }
    else {
        LogWarning("Key mock error.\n");
    }
}
void HalTestTool::SetKeyClick(const std::string &keyName, const unsigned int &pressingTimeMs)
{
    std::shared_ptr<VKeyHal> key = SearchKey(keyName);
    if (!key) {
        LogError("Can't set key event, key not found.\n");
        return;
    }
    std::shared_ptr<KeyControlMock> keyMock = std::dynamic_pointer_cast<KeyControlMock>(key);
    if (keyMock) {
        if (keyMock->SetKeyClick(pressingTimeMs)) {
            DeviceManagerNotice(keyName, pressingTimeMs);
        }
    }
    else {
        LogWarning("Key mock error.\n");
    }
}
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))));
    }
}
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<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);
        // 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<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<HalCppMock> &mock)
{
    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<VKeyHal> HalTestTool::MakeKeyHalTest(const std::string &keyName)
{
    std::shared_ptr<VKeyHal> key = std::make_shared<KeyControlMock>(keyName);
    return key;
}