/*
 * 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 "McuProtocolTestTool.h"
#include "GtestUsing.h"
#include "ILog.h"
#include "LinuxApiMock.h"
#include "ModBusCRC16.h"
#include "ProtocolHandle.h"
#include "ProtocolMonitor.h"
#include "UartDevice.h"
#include "UartDeviceTestTool.h"
#if defined(__x86_64__)
    #include <bits/types/struct_timeval.h>
#endif
#include <chrono>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <gmock/gmock-spec-builders.h>
#include <gtest/gtest.h>
#include <memory>
#include <netinet/in.h>
#include <string.h>
#include <sys/select.h>
#include <sys/types.h>
#include <thread>
#include <unistd.h>

using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;
using std::placeholders::_4;
constexpr int PIPE_READ_FD_INDEX = 0;
constexpr int PIPE_WRITE_FD_INDEX = 1;
constexpr int INVALID_FD = -1;
const char *gPipeBuf = "nothing";
constexpr size_t PROTOCOL_HEAD_LENGTH = 2;
constexpr size_t PROTOCOL_SERIAL_NUMBER_LENGTH = sizeof(unsigned int);
constexpr size_t PROTOCOL_SERIAL_NUMBER_OFFSET = PROTOCOL_HEAD_LENGTH;
constexpr size_t PROTOCOL_COMMAND_LENGTH = sizeof(short);
constexpr size_t PROTOCOL_COMMAND_OFFSET = PROTOCOL_SERIAL_NUMBER_OFFSET + PROTOCOL_SERIAL_NUMBER_LENGTH;
constexpr size_t PROTOCOL_DATA_LENGTH_LENGTH = sizeof(short);
constexpr size_t PROTOCOL_DATA_LENGTH_OFFSET = PROTOCOL_COMMAND_OFFSET + PROTOCOL_DATA_LENGTH_LENGTH;
constexpr size_t PROTOCOL_CHECK_CODE_LENGTH = sizeof(short);
constexpr size_t PROTOCOL_DATA_KEY_HEAD_LENGTH =
    PROTOCOL_HEAD_LENGTH + PROTOCOL_SERIAL_NUMBER_LENGTH + PROTOCOL_COMMAND_LENGTH + PROTOCOL_DATA_LENGTH_LENGTH;
constexpr size_t PROTOCOL_DATA_OFFSET = PROTOCOL_DATA_KEY_HEAD_LENGTH;
unsigned char ASK_IPC_MISSION_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_IPC_MISSION_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_CUT_OFF_POWER_SUPPLY_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x02, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char ASK_FEED_WATCH_DOG_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x03, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char ASK_SET_FEEDING_CYCLE_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x81, 0x04, 0x00, 0x0F, 0x01, 0x01, 0xFF, 0xFF};
unsigned char REPLY_SET_FEEDING_CYCLE_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_SET_DATE_TIME_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x07, 0x00, 0x12, 0x20, 0x01, 0x0F, 0x00, 0x00, 0x00, 0xFF, 0xFF};
unsigned char REPLY_SET_DATE_TIME_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_SET_PIR_SENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x08, 0x00, 0x0D, 0x09, 0xFF, 0xFF};
unsigned char REPLY_SET_PIR_SENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_CONTORL_INFRARED_LIGHT_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x0A, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char REPLY_ASK_CONTORL_INFRARED_LIGHT_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0A, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char ASK_GET_PHOTOSENSITIVITY_X[] = {0xFA, 0xC1, 0x00, 0x00, 0x00, 0x01, 0x81, 0x0B, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_ASK_GET_PHOTOSENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0B, 0x00, 0x0D, 0x0A, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x01, 0x00, 0x0D, 0x0A, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_SEND_IPC_MISSION_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x01, 0x00, 0x0D, 0x01, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x02, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_SEND_HEART_BEAT_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x02, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x06, 0x00, 0x0F, 0x00, 0x00, 0x00, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_GET_INTERVAL_START_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x06, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_GET_DATE_TIME_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x07, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_GET_DATE_TIME_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x07, 0x00, 0x0C, 0xFF, 0xFF};
unsigned char REPLY_OTHER_SIDE_ASK_GET_SENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x08, 0x00, 0x0C, 0x00, 0xFF, 0xFF};
unsigned char OTHER_SIDE_ASK_GET_SENSITIVITY_X[] = {
    0xFA, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x41, 0x08, 0x00, 0x0C, 0xFF, 0xFF};
McuProtocolTestTool::McuProtocolTestTool()
{
    mThreadRuning = false;
    mPipeFdMockSelectInit = false;
    mPipeFdMockSelect[PIPE_READ_FD_INDEX] = -1;
    mPipeFdMockSelect[PIPE_WRITE_FD_INDEX] = -1;
    mUartFd = INVALID_FD;
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::MonitorProtocolPacket, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::IpcMissionProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::CutOffPowerSupplyProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::FeedWatchDogProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::FeedingCycleProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::SetDataTimeProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::SetPirSensitivityProtocolHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::ContorlInfraredLightHandle, this, _1, _2, _3, _4));
    mProtocolHandle.push_back(std::bind(&McuProtocolTestTool::GetPhotosensitivityValueHandle, this, _1, _2, _3, _4));
}
void McuProtocolTestTool::Init(std::shared_ptr<LinuxTest> &mock, const UartInfo &uart)
{
    std::shared_ptr<ProtocolMonitor> test = std::make_shared<ProtocolMonitorTest>();
    std::shared_ptr<ProtocolMonitorTest> tmp = std::dynamic_pointer_cast<ProtocolMonitorTest>(test);
    ProtocolMonitorTest::Init(tmp);
    ProtocolMonitor::GetInstance(&test);
    if (pipe(mPipeFdMockSelect) == 0) {
        mPipeFdMockSelectInit = true;
    }
    else {
        LogWarning("pipe failed, mPipeFdMockSelect willn,t work.\n");
    }
    int uartFd = GetDeviceMockFd(uart);
    mUart = std::make_shared<UartInfo>(uart);
    mUartFd = uartFd;
    static size_t WRITE_COUNT = -1;
    auto api_write = [=, &mock](int fd, const void *buf, size_t count) {
        McuProtocolTestTool::PrintHexadecimalData(buf, count, "app write :");
        CheckSerialNumber(buf, count);
        ChecCRC16Code(buf, count);
        for (auto iter = mProtocolHandle.begin(); iter != mProtocolHandle.end(); ++iter) {
            if ((*iter)(mock, uartFd, buf, count) == PROTOCOL_HANDLED) {
                return;
            }
        }
        LogWarning("Can't find protocol handle function.\n");
    };
    EXPECT_CALL(*mock.get(), fx_write(uartFd, _, _))
        .WillRepeatedly(
            DoAll(SaveArg<2>(&WRITE_COUNT), WithArgs<0, 1, 2>(Invoke(api_write)), ReturnPointee(&WRITE_COUNT)));
    SelectInit(mock, mUartFd);
    InitProtocolBuff();
}
void McuProtocolTestTool::UnInit(void)
{
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    if (mUnLockThread.joinable()) {
        mUnLockThread.join();
    }
    mSerialNumberList.clear();
    if (mPipeFdMockSelectInit) {
        mPipeFdMockSelectInit = false;
        close(mPipeFdMockSelect[PIPE_READ_FD_INDEX]);
        close(mPipeFdMockSelect[PIPE_WRITE_FD_INDEX]);
        mPipeFdMockSelect[PIPE_READ_FD_INDEX] = -1;
        mPipeFdMockSelect[PIPE_WRITE_FD_INDEX] = -1;
    }
    mUartFd = INVALID_FD;
    std::shared_ptr<ProtocolMonitor> monitor = std::make_shared<ProtocolMonitor>();
    ProtocolMonitor::GetInstance(&monitor);
}
void McuProtocolTestTool::MockOtherSideAskIpcMission(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber)
{
    OtherSideAskIpcMissionHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::MockOtherSideAskHeartBeat(std::shared_ptr<LinuxTest> &mock, const unsigned int &serialNumber)
{
    OtherSideAskHeartBeatHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::MockOtherSideAskGetIntervalStart(std::shared_ptr<LinuxTest> &mock,
                                                           const unsigned int &serialNumber)
{
    OtherSideAskGetIntervalStartHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::MockOtherSideAskGetDateTime(std::shared_ptr<LinuxTest> &mock,
                                                      const unsigned int &serialNumber)
{
    OtherSideAskGetDateTimeHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::MockOtherSideAskGetPirSensitivity(std::shared_ptr<LinuxTest> &mock,
                                                            const unsigned int &serialNumber)
{
    OtherSideAskGetPirSensitivityHandle(mock, mUartFd, serialNumber);
}
void McuProtocolTestTool::MockOtherSideAskSendAnyData(std::shared_ptr<LinuxTest> &mock, const void *data,
                                                      const size_t &size)
{
    OtherSideAskSendSomeDataHandle(mock, mUartFd, data, size);
}
void McuProtocolTestTool::ReadNothingAnyTime(std::shared_ptr<LinuxTest> &mock)
{
    static size_t WRITE_COUNT = -1;
    EXPECT_CALL(*mock.get(), fx_write(mUartFd, _, _))
        .WillRepeatedly(DoAll(SaveArg<2>(&WRITE_COUNT), ReturnPointee(&WRITE_COUNT)));
    if (mUart) {
        UartDeviceTestTool::SetUartDeviceReadNothing(mock, *mUart.get());
    }
    else {
        LogWarning("mUart is null.\n");
    }
}
void McuProtocolTestTool::InitProtocolBuff(void)
{
    REPLY_IPC_MISSION_X[PROTOCOL_DATA_OFFSET] = 0x01;
}
void McuProtocolTestTool::CheckSerialNumber(const void *buf, const size_t &count)
{
    unsigned int serialNumber = 0;
    if (count > PROTOCOL_COMMAND_OFFSET + PROTOCOL_CHECK_CODE_LENGTH) {
        memcpy(&serialNumber, (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET, PROTOCOL_SERIAL_NUMBER_LENGTH);
        for (auto iter = mSerialNumberList.begin(); iter != mSerialNumberList.end(); ++iter) {
            EXPECT_NE(*iter, serialNumber);
        }
        mSerialNumberList.push_back(serialNumber);
    }
}
void McuProtocolTestTool::ChecCRC16Code(const void *buf, const size_t &count)
{
    short checkCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
    if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
        checkCode = ntohs(checkCode);
    }
    EXPECT_EQ(memcmp((unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &checkCode, PROTOCOL_CHECK_CODE_LENGTH),
              0);
}
void McuProtocolTestTool::ResetCheckCode(const void *buf, const size_t &count)
{
    short checkCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
    if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
        checkCode = ntohs(checkCode);
    }
    memcpy((unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &checkCode, PROTOCOL_CHECK_CODE_LENGTH);
}
void McuProtocolTestTool::SelectInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
{
    auto selectTimeOut =
        [=, &mock](int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
            if (false == mPipeFdMockSelectInit) {
                long long timeMs = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
                std::this_thread::sleep_for(std::chrono::milliseconds(timeMs));
            }
            else {
                constexpr int READ_BUF_LENGTH = 256;
                constexpr int READ_FAILD = -1;
                char buf[READ_BUF_LENGTH] = {0};
                int selectResult = -1;
                fd_set fdsRead;
                FD_ZERO(&fdsRead);
                FD_SET(mPipeFdMockSelect[PIPE_READ_FD_INDEX], &fdsRead);
                selectResult = select(mPipeFdMockSelect[PIPE_READ_FD_INDEX] + 1, &fdsRead, NULL, NULL, timeout);
                if (selectResult) {
                    if (false == mPipeFdMockSelectInit) {
                        LogWarning("mPipeFdMockSelectInit = false.\n");
                        return;
                    }
                    ssize_t length = read(mPipeFdMockSelect[PIPE_READ_FD_INDEX], buf, READ_BUF_LENGTH);
                    if (READ_FAILD == length) {
                        LogError("mPipeFdMockSelect failed.\n");
                        return;
                    }
                    if ((size_t)length != strlen(gPipeBuf)) {
                        LogWarning("Something wrong happened.\n");
                    }
                }
            }
        };
    EXPECT_CALL(*mock.get(), fx_select(uartFd + 1, _, _, _, _))
        .WillRepeatedly(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectTimeOut)), Return(MOCK_SELECT_TIME_OUT)));
}
void McuProtocolTestTool::ReplySelectSucceed(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
{
    auto selectReadable =
        [=, &mock](int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
            FD_ZERO(readfds);
            FD_SET(uartFd, readfds);
        };
    auto selectTimeOut =
        [=, &mock](int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
            if (false == mPipeFdMockSelectInit) {
                long long timeMs = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
                std::this_thread::sleep_for(std::chrono::milliseconds(timeMs));
            }
            else {
                constexpr int READ_BUF_LENGTH = 256;
                constexpr int READ_FAILD = -1;
                char buf[READ_BUF_LENGTH] = {0};
                int selectResult = -1;
                fd_set fdsRead;
                FD_ZERO(&fdsRead);
                FD_SET(mPipeFdMockSelect[PIPE_READ_FD_INDEX], &fdsRead);
                selectResult = select(mPipeFdMockSelect[PIPE_READ_FD_INDEX] + 1, &fdsRead, NULL, NULL, timeout);
                if (selectResult) {
                    if (false == mPipeFdMockSelectInit) {
                        LogWarning("mPipeFdMockSelectInit = false.\n");
                        return;
                    }
                    ssize_t length = read(mPipeFdMockSelect[PIPE_READ_FD_INDEX], buf, READ_BUF_LENGTH);
                    if (READ_FAILD == length) {
                        LogError("mPipeFdMockSelect failed.\n");
                        return;
                    }
                    if ((size_t)length != strlen(gPipeBuf)) {
                        LogWarning("Something wrong happened.\n");
                    }
                }
            }
        };
    EXPECT_CALL(*mock.get(), fx_select(uartFd + 1, _, _, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectReadable)), Return(1)))
        .WillOnce(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectReadable)), Return(1)))
        .WillRepeatedly(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectTimeOut)), Return(MOCK_SELECT_TIME_OUT)));
    PipeSelectTimeoutForProtocolHandleImmediately();
}
void McuProtocolTestTool::ReadOnceSelectSucceed(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
{
    auto selectReadable =
        [=, &mock](int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
            FD_ZERO(readfds);
            FD_SET(uartFd, readfds);
        };
    auto selectTimeOut =
        [=, &mock](int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
            if (false == mPipeFdMockSelectInit) {
                long long timeMs = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
                std::this_thread::sleep_for(std::chrono::milliseconds(timeMs));
            }
            else {
                constexpr int READ_BUF_LENGTH = 256;
                constexpr int READ_FAILD = -1;
                char buf[READ_BUF_LENGTH] = {0};
                int selectResult = -1;
                fd_set fdsRead;
                FD_ZERO(&fdsRead);
                FD_SET(mPipeFdMockSelect[PIPE_READ_FD_INDEX], &fdsRead);
                selectResult = select(mPipeFdMockSelect[PIPE_READ_FD_INDEX] + 1, &fdsRead, NULL, NULL, timeout);
                if (selectResult) {
                    if (false == mPipeFdMockSelectInit) {
                        LogWarning("mPipeFdMockSelectInit = false.\n");
                        return;
                    }
                    ssize_t length = read(mPipeFdMockSelect[PIPE_READ_FD_INDEX], buf, READ_BUF_LENGTH);
                    if (READ_FAILD == length) {
                        LogError("mPipeFdMockSelect failed.\n");
                        return;
                    }
                    if ((size_t)length != strlen(gPipeBuf)) {
                        LogWarning("Something wrong happened.\n");
                    }
                }
            }
        };
    EXPECT_CALL(*mock.get(), fx_select(uartFd + 1, _, _, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectReadable)), Return(1)))
        .WillRepeatedly(DoAll(WithArgs<0, 1, 2, 3, 4>(Invoke(selectTimeOut)), Return(MOCK_SELECT_TIME_OUT)));
    PipeSelectTimeoutForProtocolHandleImmediately();
}
void McuProtocolTestTool::MockOtherSideIpcMissionReply(const unsigned char &replyIpcMission)
{
    REPLY_IPC_MISSION_X[PROTOCOL_DATA_OFFSET] = replyIpcMission;
}
void McuProtocolTestTool::ReplySelectTimeOut(std::shared_ptr<LinuxTest> &mock, const int &uartFd)
{
    if (mUart) {
        UartDeviceTestTool::SetUartDeviceTimeOut(mock, *mUart.get());
    }
    else {
        LogWarning("mUart is null.\n");
    }
}
bool McuProtocolTestTool::MonitorProtocolPacket(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                size_t count)
{
    LogInfo("MonitorProtocolPacket\n");
    short head;
    unsigned int serialNumber;
    short command;
    void *data;
    short packetLength;
    memcpy(&head, buf, PROTOCOL_HEAD_LENGTH);
    memcpy(&serialNumber, (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET, PROTOCOL_SERIAL_NUMBER_LENGTH);
    memcpy(&command, (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET, PROTOCOL_COMMAND_LENGTH);
    memcpy(&packetLength, (unsigned char *)buf + PROTOCOL_DATA_LENGTH_OFFSET, PROTOCOL_DATA_LENGTH_LENGTH);
    data = (unsigned char *)buf + PROTOCOL_DATA_KEY_HEAD_LENGTH;
    head = ntohs(head);
    serialNumber = ntohl(serialNumber);
    command = ntohs(command);
    packetLength = ntohs(packetLength);
    ProtocolMonitor::GetInstance()->MonitorWriteProtocolData(head, serialNumber, command, data, packetLength);
    return PROTOCOL_NOT_HANDLED;
}
bool McuProtocolTestTool::IpcMissionProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                   size_t count)
{
    if (sizeof(ASK_IPC_MISSION_X) == count && memcmp(ASK_IPC_MISSION_X + PROTOCOL_COMMAND_OFFSET,
                                                     (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                     PROTOCOL_COMMAND_LENGTH) == 0) {
        LogInfo("Set REPLY_IPC_MISSION_X\n");
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
            askCheckCode = ntohs(askCheckCode);
        }
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        unsigned char *bufHandle = (unsigned char *)malloc(count);
        if (nullptr == bufHandle) {
            LogError("malloc failed.\n");
            return PROTOCOL_HANDLED;
        }
        memcpy(bufHandle, buf, count);
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->IpcMissionProtocolInit(mock, uartFd, bufHandle, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::IpcMissionProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                 size_t count)
{
    LockProtocolHandle();
    LogInfo("IpcMissionProtocolInit start.\n");
    memcpy(REPLY_IPC_MISSION_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    free((void *)buf);
    ResetCheckCode(REPLY_IPC_MISSION_X, sizeof(REPLY_IPC_MISSION_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_IPC_MISSION_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_IPC_MISSION_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "IpcMissionProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_IPC_MISSION_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "IpcMissionProtocolInit read:");
        UnlockProtocolHandle();
        LogInfo("IpcMissionProtocolInit finished.\n");
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::CutOffPowerSupplyProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                          const void *buf, size_t count)
{
    if (sizeof(ASK_CUT_OFF_POWER_SUPPLY_X) == count && memcmp(ASK_CUT_OFF_POWER_SUPPLY_X + PROTOCOL_COMMAND_OFFSET,
                                                              (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                              PROTOCOL_COMMAND_LENGTH) == 0) {
        LogInfo("Set ASK_CUT_OFF_POWER_SUPPLY_X\n");
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
            askCheckCode = ntohs(askCheckCode);
        }
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
bool McuProtocolTestTool::FeedWatchDogProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const void *buf, size_t count)
{
    if (sizeof(ASK_FEED_WATCH_DOG_X) == count && memcmp(ASK_FEED_WATCH_DOG_X + PROTOCOL_COMMAND_OFFSET,
                                                        (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                        PROTOCOL_COMMAND_LENGTH) == 0) {
        LogInfo("Set ASK_FEED_WATCH_DOG_X\n");
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
            askCheckCode = ntohs(askCheckCode);
        }
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
bool McuProtocolTestTool::FeedingCycleProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const void *buf, size_t count)
{
    if (sizeof(ASK_SET_FEEDING_CYCLE_X) == count && memcmp(ASK_SET_FEEDING_CYCLE_X + PROTOCOL_COMMAND_OFFSET,
                                                           (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                           PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode = calculate_check_sum(REPLY_SET_FEEDING_CYCLE_X,
                                                   sizeof(REPLY_SET_FEEDING_CYCLE_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_SET_FEEDING_CYCLE_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
            askCheckCode = ntohs(askCheckCode);
        }
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        unsigned char *bufHandle = (unsigned char *)malloc(count);
        if (nullptr == bufHandle) {
            LogError("malloc failed.\n");
            return PROTOCOL_HANDLED;
        }
        memcpy(bufHandle, buf, count);
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->FeedingCycleProtocolInit(mock, uartFd, bufHandle, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::FeedingCycleProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                   size_t count)
{
    LockProtocolHandle();
    LogInfo("FeedingCycleProtocolInit start.\n");
    memcpy(REPLY_SET_FEEDING_CYCLE_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    free((void *)buf);
    ResetCheckCode(REPLY_SET_FEEDING_CYCLE_X, sizeof(REPLY_SET_FEEDING_CYCLE_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_FEEDING_CYCLE_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_FEEDING_CYCLE_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "FeedingCycleProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_FEEDING_CYCLE_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "FeedingCycleProtocolInit read:");
        UnlockProtocolHandle();
        LogInfo("FeedingCycleProtocolInit finished.\n");
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::SetDataTimeProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                    const void *buf, size_t count)
{
    if (sizeof(ASK_SET_DATE_TIME_X) == count && memcmp(ASK_SET_DATE_TIME_X + PROTOCOL_COMMAND_OFFSET,
                                                       (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                       PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode =
            calculate_check_sum(REPLY_SET_DATE_TIME_X, sizeof(REPLY_SET_DATE_TIME_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_SET_DATE_TIME_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
            askCheckCode = ntohs(askCheckCode);
        }
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        unsigned char *bufHandle = (unsigned char *)malloc(count);
        if (nullptr == bufHandle) {
            LogError("malloc failed.\n");
            return PROTOCOL_HANDLED;
        }
        memcpy(bufHandle, buf, count);
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->SetDataTimeProtocolInit(mock, uartFd, bufHandle, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::SetDataTimeProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                  size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_SET_DATE_TIME_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    free((void *)buf);
    ResetCheckCode(REPLY_SET_DATE_TIME_X, sizeof(REPLY_SET_DATE_TIME_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_DATE_TIME_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_DATE_TIME_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "SetDataTimeProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_DATE_TIME_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "SetDataTimeProtocolInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::SetPirSensitivityProtocolHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                          const void *buf, size_t count)
{
    if (sizeof(ASK_SET_PIR_SENSITIVITY_X) == count && memcmp(ASK_SET_PIR_SENSITIVITY_X + PROTOCOL_COMMAND_OFFSET,
                                                             (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                             PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode = calculate_check_sum(REPLY_SET_PIR_SENSITIVITY_X,
                                                   sizeof(REPLY_SET_PIR_SENSITIVITY_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_SET_PIR_SENSITIVITY_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        if (ORDER_LITTLE_ENDIAN == ProtocolHandle::GetByteOrder()) {
            askCheckCode = ntohs(askCheckCode);
        }
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        unsigned char *bufHandle = (unsigned char *)malloc(count);
        if (nullptr == bufHandle) {
            LogError("malloc failed.\n");
            return PROTOCOL_HANDLED;
        }
        memcpy(bufHandle, buf, count);
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->SetDataTimeProtocolInit(mock, uartFd, bufHandle, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::SetPirSensitivityProtocolInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                        const void *buf, size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_SET_PIR_SENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(REPLY_SET_PIR_SENSITIVITY_X, sizeof(REPLY_SET_PIR_SENSITIVITY_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_SET_PIR_SENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_PIR_SENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "SetPirSensitivityProtocolInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_SET_PIR_SENSITIVITY_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "SetPirSensitivityProtocolInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::ContorlInfraredLightHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const void *buf, size_t count)
{
    if (sizeof(ASK_CONTORL_INFRARED_LIGHT_X) == count && memcmp(ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_COMMAND_OFFSET,
                                                                (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                                PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode =
            calculate_check_sum(REPLY_ASK_CONTORL_INFRARED_LIGHT_X,
                                sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_CONTORL_INFRARED_LIGHT_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        unsigned char *bufHandle = (unsigned char *)malloc(count);
        if (nullptr == bufHandle) {
            LogError("malloc failed.\n");
            return PROTOCOL_HANDLED;
        }
        memcpy(bufHandle, buf, count);
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->ContorlInfraredLightInit(mock, uartFd, bufHandle, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::ContorlInfraredLightInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd, const void *buf,
                                                   size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    free((void *)buf);
    ResetCheckCode(REPLY_ASK_CONTORL_INFRARED_LIGHT_X, sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_ASK_CONTORL_INFRARED_LIGHT_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_CONTORL_INFRARED_LIGHT_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "ContorlInfraredLightInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_CONTORL_INFRARED_LIGHT_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "ContorlInfraredLightInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
}
bool McuProtocolTestTool::GetPhotosensitivityValueHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                         const void *buf, size_t count)
{
    if (sizeof(ASK_GET_PHOTOSENSITIVITY_X) == count && memcmp(ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_COMMAND_OFFSET,
                                                              (unsigned char *)buf + PROTOCOL_COMMAND_OFFSET,
                                                              PROTOCOL_COMMAND_LENGTH) == 0) {
        short replyCheckCode = calculate_check_sum(
            REPLY_ASK_GET_PHOTOSENSITIVITY_X, sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X) - PROTOCOL_CHECK_CODE_LENGTH);
        replyCheckCode = htons(replyCheckCode);
        LogInfo("Set ASK_GET_PHOTOSENSITIVITY_X, reply data check code = 0x%x\n", replyCheckCode);
        short askCheckCode = calculate_check_sum((unsigned char *)buf, count - PROTOCOL_CHECK_CODE_LENGTH);
        // askCheckCode = htons(askCheckCode);
        int result = memcmp(
            (unsigned char *)buf + count - PROTOCOL_CHECK_CODE_LENGTH, &askCheckCode, PROTOCOL_CHECK_CODE_LENGTH);
        EXPECT_EQ(result, 0) << "ask protocol data errer, check code isn't right.";
        unsigned char *bufHandle = (unsigned char *)malloc(count);
        if (nullptr == bufHandle) {
            LogError("malloc failed.\n");
            return PROTOCOL_HANDLED;
        }
        memcpy(bufHandle, buf, count);
        auto handle = [=, &mock](McuProtocolTestTool *testTool) {
            testTool->GetPhotosensitivityValueInit(mock, uartFd, bufHandle, count);
        };
        if (mLockThread.joinable()) {
            mLockThread.join();
        }
        mLockThread = std::thread(handle, this);
        return PROTOCOL_HANDLED;
    }
    return PROTOCOL_NOT_HANDLED;
}
void McuProtocolTestTool::GetPhotosensitivityValueInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                       const void *buf, size_t count)
{
    LockProtocolHandle();
    memcpy(REPLY_ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET,
           (unsigned char *)buf + PROTOCOL_SERIAL_NUMBER_OFFSET,
           PROTOCOL_SERIAL_NUMBER_LENGTH);
    free((void *)buf);
    ResetCheckCode(REPLY_ASK_GET_PHOTOSENSITIVITY_X, sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(REPLY_ASK_GET_PHOTOSENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_GET_PHOTOSENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "GetPhotosensitivityValueInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, REPLY_ASK_GET_PHOTOSENSITIVITY_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "GetPhotosensitivityValueInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
}
void McuProtocolTestTool::UnlockProtocolHandle(void)
{
    auto unlockThread = [=](McuProtocolTestTool *testTool) {
        testTool->UnlockThread();
    };
    if (mUnLockThread.joinable()) {
        mUnLockThread.join();
    }
    mUnLockThread = std::thread(unlockThread, this);
}
void McuProtocolTestTool::LockProtocolHandle(void)
{
    mMutex.lock();
}
void McuProtocolTestTool::UnlockThread(void)
{
    std::this_thread::sleep_for(std::chrono::milliseconds(5));
    mMutex.unlock();
}
void McuProtocolTestTool::PipeSelectTimeoutForProtocolHandleImmediately(void)
{
    constexpr int WRITE_FAILD = -1;
    if (true == mPipeFdMockSelectInit) {
        ssize_t length = write(mPipeFdMockSelect[PIPE_WRITE_FD_INDEX], gPipeBuf, strlen(gPipeBuf));
        if (WRITE_FAILD == length) {
            LogError("mPipeFdMockSelect failed.\n");
            return;
        }
        if ((size_t)length != strlen(gPipeBuf)) {
            LogWarning("Something wrong happened.\n");
        }
    }
}
void McuProtocolTestTool::OtherSideAskIpcMissionHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                       const unsigned int &serialNumber)
{
    LogInfo("OtherSideAskIpcMissionHandle\n");
    auto handle = [=, &mock](McuProtocolTestTool *testTool) {
        testTool->OtherSideAskIpcMissionInit(mock, uartFd, serialNumber);
    };
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskIpcMissionInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                     const unsigned int &serialNumber)
{
    LockProtocolHandle();
    LogInfo("OtherSideAskIpcMissionInit start.\n");
    unsigned int serialNum = serialNumber;
    serialNum = htonl(serialNum);
    memcpy(
        OTHER_SIDE_ASK_SEND_IPC_MISSION_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(OTHER_SIDE_ASK_SEND_IPC_MISSION_X, sizeof(OTHER_SIDE_ASK_SEND_IPC_MISSION_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_SEND_IPC_MISSION_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_SEND_IPC_MISSION_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskIpcMissionInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_SEND_IPC_MISSION_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskIpcMissionInit read:");
        UnlockProtocolHandle();
        LogInfo("OtherSideAskIpcMissionInit finished.\n");
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
    std::shared_ptr<ProtocolMonitorTest> test =
        std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
    if (test) {
        ProtocolMonitorTest::WriteDataOnce(test,
                                           PROTOCOL_HEAD,
                                           serialNumber,
                                           REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION,
                                           nullptr,
                                           sizeof(REPLY_OTHER_SIDE_ASK_SEND_IPC_MISSION_X));
    }
}
void McuProtocolTestTool::OtherSideAskHeartBeatHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                      const unsigned int &serialNumber)
{
    LogInfo("OtherSideAskHeartBeatHandle\n");
    auto handle = [=, &mock](McuProtocolTestTool *testTool) {
        testTool->OtherSideAskHeartBeatInit(mock, uartFd, serialNumber);
    };
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskHeartBeatInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                    const unsigned int &serialNumber)
{
    LockProtocolHandle();
    unsigned int serialNum = serialNumber;
    serialNum = htonl(serialNum);
    memcpy(OTHER_SIDE_ASK_SEND_HEART_BEAT_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(OTHER_SIDE_ASK_SEND_HEART_BEAT_X, sizeof(OTHER_SIDE_ASK_SEND_HEART_BEAT_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_SEND_HEART_BEAT_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_SEND_HEART_BEAT_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskHeartBeatInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_SEND_HEART_BEAT_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskHeartBeatInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
    std::shared_ptr<ProtocolMonitorTest> test =
        std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
    if (test) {
        ProtocolMonitorTest::WriteDataOnce(test,
                                           PROTOCOL_HEAD,
                                           serialNumber,
                                           REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT,
                                           nullptr,
                                           sizeof(REPLY_OTHER_SIDE_ASK_SEND_HEART_BEAT_X));
    }
}
void McuProtocolTestTool::OtherSideAskGetIntervalStartHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                             const unsigned int &serialNumber)
{
    LogInfo("OtherSideAskGetIntervalStartHandle\n");
    auto handle = [=, &mock](McuProtocolTestTool *testTool) {
        testTool->OtherSideAskGetIntervalStartInit(mock, uartFd, serialNumber);
    };
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskGetIntervalStartInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                           const unsigned int &serialNumber)
{
    LockProtocolHandle();
    unsigned int serialNum = serialNumber;
    serialNum = htonl(serialNum);
    memcpy(
        OTHER_SIDE_ASK_GET_INTERVAL_START_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(OTHER_SIDE_ASK_GET_INTERVAL_START_X, sizeof(OTHER_SIDE_ASK_GET_INTERVAL_START_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_GET_INTERVAL_START_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_GET_INTERVAL_START_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskGetIntervalStartInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_GET_INTERVAL_START_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskGetIntervalStartInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
    std::shared_ptr<ProtocolMonitorTest> test =
        std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
    if (test) {
        ProtocolMonitorTest::WriteDataOnce(test,
                                           PROTOCOL_HEAD,
                                           serialNumber,
                                           REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START,
                                           nullptr,
                                           sizeof(REPLY_OTHER_SIDE_ASK_GET_INTERVAL_START_X));
    }
}
void McuProtocolTestTool::OtherSideAskGetDateTimeHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                        const unsigned int &serialNumber)
{
    LogInfo("OtherSideAskGetDateTimeHandle\n");
    auto handle = [=, &mock](McuProtocolTestTool *testTool) {
        testTool->OtherSideAskGetDateTimeInit(mock, uartFd, serialNumber);
    };
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskGetDateTimeInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                      const unsigned int &serialNumber)
{
    LockProtocolHandle();
    unsigned int serialNum = serialNumber;
    serialNum = htonl(serialNum);
    memcpy(OTHER_SIDE_ASK_GET_DATE_TIME_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(OTHER_SIDE_ASK_GET_DATE_TIME_X, sizeof(OTHER_SIDE_ASK_GET_DATE_TIME_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_GET_DATE_TIME_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_GET_DATE_TIME_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskGetDateTimeInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_GET_DATE_TIME_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskGetDateTimeInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
    std::shared_ptr<ProtocolMonitorTest> test =
        std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
    if (test) {
        ProtocolMonitorTest::WriteDataOnce(test,
                                           PROTOCOL_HEAD,
                                           serialNumber,
                                           REPLY_OTHER_SIDE_ASK_GET_DATE_TIME,
                                           nullptr,
                                           sizeof(REPLY_OTHER_SIDE_ASK_GET_DATE_TIME_X));
    }
}
void McuProtocolTestTool::OtherSideAskGetPirSensitivityHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                              const unsigned int &serialNumber)
{
    LogInfo("OtherSideAskGetPirSensitivityHandle\n");
    auto handle = [=, &mock](McuProtocolTestTool *testTool) {
        testTool->OtherSideAskGetPirSensitivityInit(mock, uartFd, serialNumber);
    };
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskGetPirSensitivityInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                            const unsigned int &serialNumber)
{
    LockProtocolHandle();
    unsigned int serialNum = serialNumber;
    serialNum = htonl(serialNum);
    memcpy(OTHER_SIDE_ASK_GET_SENSITIVITY_X + PROTOCOL_SERIAL_NUMBER_OFFSET, &serialNum, PROTOCOL_SERIAL_NUMBER_LENGTH);
    ResetCheckCode(OTHER_SIDE_ASK_GET_SENSITIVITY_X, sizeof(OTHER_SIDE_ASK_GET_SENSITIVITY_X));
    constexpr int LEFT_DATA_LENGTH = sizeof(OTHER_SIDE_ASK_GET_SENSITIVITY_X) - PROTOCOL_DATA_KEY_HEAD_LENGTH;
    auto apiReadKeyHead = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_GET_SENSITIVITY_X, PROTOCOL_DATA_KEY_HEAD_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(
            buf, PROTOCOL_DATA_KEY_HEAD_LENGTH, "OtherSideAskGetPirSensitivityInit read:");
    };
    auto apiReadLeftData = [=](int fd, void *buf, size_t count) {
        memcpy(buf, OTHER_SIDE_ASK_GET_SENSITIVITY_X + PROTOCOL_DATA_KEY_HEAD_LENGTH, LEFT_DATA_LENGTH);
        McuProtocolTestTool::PrintHexadecimalData(buf, LEFT_DATA_LENGTH, "OtherSideAskGetPirSensitivityInit read:");
        UnlockProtocolHandle();
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadKeyHead)), Return(PROTOCOL_DATA_KEY_HEAD_LENGTH)))
        .WillOnce(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), Return(LEFT_DATA_LENGTH)))
        .WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
    ReplySelectSucceed(mock, uartFd);
    std::shared_ptr<ProtocolMonitorTest> test =
        std::dynamic_pointer_cast<ProtocolMonitorTest>(ProtocolMonitorTest::GetInstance());
    if (test) {
        ProtocolMonitorTest::WriteDataOnce(test,
                                           PROTOCOL_HEAD,
                                           serialNumber,
                                           REPLY_OTHER_SIDE_ASK_GET_PIR_SENSITIVITY,
                                           nullptr,
                                           sizeof(REPLY_OTHER_SIDE_ASK_GET_SENSITIVITY_X));
    }
}
void McuProtocolTestTool::OtherSideAskSendSomeDataHandle(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                         const void *data, const size_t &size)
{
    LogInfo("OtherSideAskSendSomeDataHandle\n");
    auto handle = [=, &mock](McuProtocolTestTool *testTool) {
        testTool->OtherSideAskSendSomeDataInit(mock, uartFd, data, size);
    };
    if (mLockThread.joinable()) {
        mLockThread.join();
    }
    mLockThread = std::thread(handle, this);
}
void McuProtocolTestTool::OtherSideAskSendSomeDataInit(std::shared_ptr<LinuxTest> &mock, const int &uartFd,
                                                       const void *data, const size_t &size)
{
    LockProtocolHandle();
    static size_t totalLength = 0;
    static size_t leftDataLength = 0;
    static size_t readResult = 0;
    totalLength = size;
    leftDataLength = totalLength;
    readResult = 0;
    auto apiReadLeftData = [this, data, &mock, uartFd](int fd, void *buf, size_t count) {
        if (leftDataLength >= count) {
            memcpy(buf, (unsigned char *)data + totalLength - leftDataLength, count);
            readResult = count;
            leftDataLength = leftDataLength - count;
            McuProtocolTestTool::PrintHexadecimalData(buf, count, "OtherSideAskSendSomeDataInit read:");
        }
        else {
            memcpy(buf, (unsigned char *)data + totalLength - leftDataLength, leftDataLength);
            readResult = leftDataLength;
            leftDataLength = 0;
            McuProtocolTestTool::PrintHexadecimalData(buf, readResult, "OtherSideAskSendSomeDataInit2 read:");
        }
        if (leftDataLength > 0) {
            this->ReadOnceSelectSucceed(mock, uartFd);
        }
        else {
            EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _)).WillRepeatedly(DoAll(Return(UART_DEVICE_READ_NOTHING)));
            UnlockProtocolHandle();
        }
    };
    EXPECT_CALL(*mock.get(), fx_read(uartFd, _, _))
        .WillRepeatedly(DoAll(WithArgs<0, 1, 2>(Invoke(apiReadLeftData)), ReturnPointee(&readResult)));
    ReadOnceSelectSucceed(mock, uartFd);
}
void McuProtocolTestTool::PrintHexadecimalData(const void *buf, const size_t &bufLength, const char *log)
{
    printf("%s { 0x%02X", log, *(unsigned char *)buf);
    for (size_t i = 1; i < bufLength; i++) {
        printf(", 0x%02X", *((unsigned char *)buf + i));
    }
    printf(" }\n");
}