1089 lines
57 KiB
C++
1089 lines
57 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 "McuProtocolTestTool.h"
|
|
#include "ILog.h"
|
|
#include "ModBusCRC16.h"
|
|
#include "ProtocolHandle.h"
|
|
#include "ProtocolMonitor.h"
|
|
#include <netinet/in.h>
|
|
#include <string.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;
|
|
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, 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);
|
|
}
|
|
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::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::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");
|
|
} |