Michal
/
Prusa-Firmware-MMU
mirror of https://github.com/prusa3d/Prusa-Firmware-MMU
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Prusa-Firmware-MMU/tests/unit/modules/protocol/test_protocol.cpp

357 lines
13 KiB
C++
Raw Blame History

#include "catch2/catch.hpp"
#include "protocol.h"
using Catch::Matchers::Equals;
TEST_CASE("protocol::EncodeRequests", "[protocol]") {
using namespace modules;
RequestMsgCodes code;
uint8_t value;
std::tie(code, value) = GENERATE(
std::make_tuple(RequestMsgCodes::Button, 0),
std::make_tuple(RequestMsgCodes::Button, 1),
std::make_tuple(RequestMsgCodes::Button, 2),
std::make_tuple(RequestMsgCodes::Cut, 0),
std::make_tuple(RequestMsgCodes::Eject, 0),
std::make_tuple(RequestMsgCodes::Finda, 0),
std::make_tuple(RequestMsgCodes::Load, 0),
std::make_tuple(RequestMsgCodes::Load, 1),
std::make_tuple(RequestMsgCodes::Load, 2),
std::make_tuple(RequestMsgCodes::Load, 3),
std::make_tuple(RequestMsgCodes::Load, 4),
std::make_tuple(RequestMsgCodes::Mode, 0),
std::make_tuple(RequestMsgCodes::Mode, 1),
std::make_tuple(RequestMsgCodes::Query, 0),
std::make_tuple(RequestMsgCodes::Reset, 0),
std::make_tuple(RequestMsgCodes::Tool, 0),
std::make_tuple(RequestMsgCodes::Tool, 1),
std::make_tuple(RequestMsgCodes::Tool, 2),
std::make_tuple(RequestMsgCodes::Tool, 3),
std::make_tuple(RequestMsgCodes::Tool, 4),
std::make_tuple(RequestMsgCodes::Unload, 0),
std::make_tuple(RequestMsgCodes::Version, 0),
std::make_tuple(RequestMsgCodes::Version, 1),
std::make_tuple(RequestMsgCodes::Version, 2),
std::make_tuple(RequestMsgCodes::Wait, 0),
std::make_tuple(RequestMsgCodes::unknown, 0));
std::array<uint8_t, 3> txbuff;
CHECK(Protocol::EncodeRequest(RequestMsg(code, value), txbuff.data()) == 3);
CHECK(txbuff[0] == (uint8_t)code);
CHECK(txbuff[1] == value + '0');
CHECK(txbuff[2] == '\n');
}
TEST_CASE("protocol::EncodeResponseCmdAR", "[protocol]") {
using namespace modules;
auto requestMsg = GENERATE(
RequestMsg(RequestMsgCodes::Button, 0),
RequestMsg(RequestMsgCodes::Button, 1),
RequestMsg(RequestMsgCodes::Button, 2),
RequestMsg(RequestMsgCodes::Cut, 0),
RequestMsg(RequestMsgCodes::Eject, 0),
RequestMsg(RequestMsgCodes::Eject, 1),
RequestMsg(RequestMsgCodes::Eject, 2),
RequestMsg(RequestMsgCodes::Eject, 3),
RequestMsg(RequestMsgCodes::Eject, 4),
RequestMsg(RequestMsgCodes::Load, 0),
RequestMsg(RequestMsgCodes::Load, 1),
RequestMsg(RequestMsgCodes::Load, 2),
RequestMsg(RequestMsgCodes::Load, 3),
RequestMsg(RequestMsgCodes::Load, 4),
RequestMsg(RequestMsgCodes::Mode, 0),
RequestMsg(RequestMsgCodes::Mode, 1),
RequestMsg(RequestMsgCodes::Tool, 0),
RequestMsg(RequestMsgCodes::Tool, 1),
RequestMsg(RequestMsgCodes::Tool, 2),
RequestMsg(RequestMsgCodes::Tool, 3),
RequestMsg(RequestMsgCodes::Tool, 4),
RequestMsg(RequestMsgCodes::Unload, 0),
RequestMsg(RequestMsgCodes::Wait, 0));
auto responseStatus = GENERATE(ResponseMsgParamCodes::Accepted, ResponseMsgParamCodes::Rejected);
std::array<uint8_t, 8> txbuff;
uint8_t msglen = Protocol::EncodeResponseCmdAR(requestMsg, responseStatus, txbuff.data());
CHECK(msglen == 5);
CHECK(txbuff[0] == (uint8_t)requestMsg.code);
CHECK(txbuff[1] == requestMsg.value + '0');
CHECK(txbuff[2] == ' ');
CHECK(txbuff[3] == (uint8_t)responseStatus);
CHECK(txbuff[4] == '\n');
}
TEST_CASE("protocol::EncodeResponseReadFINDA", "[protocol]") {
using namespace modules;
auto requestMsg = RequestMsg(RequestMsgCodes::Finda, 0);
uint8_t findaStatus = GENERATE(0, 1);
std::array<uint8_t, 8> txbuff;
uint8_t msglen = Protocol::EncodeResponseReadFINDA(requestMsg, findaStatus, txbuff.data());
CHECK(msglen == 6);
CHECK(txbuff[0] == (uint8_t)requestMsg.code);
CHECK(txbuff[1] == requestMsg.value + '0');
CHECK(txbuff[2] == ' ');
CHECK(txbuff[3] == (uint8_t)ResponseMsgParamCodes::Accepted);
CHECK(txbuff[4] == findaStatus + '0');
CHECK(txbuff[5] == '\n');
}
TEST_CASE("protocol::EncodeResponseVersion", "[protocol]") {
using namespace modules;
std::uint8_t versionQueryType = GENERATE(0, 1, 2, 3);
auto requestMsg = RequestMsg(RequestMsgCodes::Version, versionQueryType);
auto version = GENERATE(0, 1, 2, 3, 4, 10, 11, 12, 20, 99, 100, 101, 255);
std::array<uint8_t, 8> txbuff;
uint8_t msglen = Protocol::EncodeResponseVersion(requestMsg, version, txbuff.data());
CHECK(msglen <= 8);
CHECK(txbuff[0] == (uint8_t)requestMsg.code);
CHECK(txbuff[1] == requestMsg.value + '0');
CHECK(txbuff[2] == ' ');
CHECK(txbuff[3] == (uint8_t)ResponseMsgParamCodes::Accepted);
if (version < 10) {
CHECK(txbuff[4] == version + '0');
} else if (version < 100) {
CHECK(txbuff[4] == version / 10 + '0');
CHECK(txbuff[5] == version % 10 + '0');
} else {
CHECK(txbuff[4] == version / 100 + '0');
CHECK(txbuff[5] == (version / 10) % 10 + '0');
CHECK(txbuff[6] == version % 10 + '0');
}
CHECK(txbuff[msglen - 1] == '\n');
}
TEST_CASE("protocol::EncodeResponseQueryOperation", "[protocol]") {
using namespace modules;
auto requestMsg = GENERATE(
RequestMsg(RequestMsgCodes::Cut, 0),
RequestMsg(RequestMsgCodes::Eject, 0),
RequestMsg(RequestMsgCodes::Eject, 1),
RequestMsg(RequestMsgCodes::Eject, 2),
RequestMsg(RequestMsgCodes::Eject, 3),
RequestMsg(RequestMsgCodes::Eject, 4),
RequestMsg(RequestMsgCodes::Load, 0),
RequestMsg(RequestMsgCodes::Load, 1),
RequestMsg(RequestMsgCodes::Load, 2),
RequestMsg(RequestMsgCodes::Load, 3),
RequestMsg(RequestMsgCodes::Load, 4),
RequestMsg(RequestMsgCodes::Tool, 0),
RequestMsg(RequestMsgCodes::Tool, 1),
RequestMsg(RequestMsgCodes::Tool, 2),
RequestMsg(RequestMsgCodes::Tool, 3),
RequestMsg(RequestMsgCodes::Tool, 4),
RequestMsg(RequestMsgCodes::Unload, 0),
RequestMsg(RequestMsgCodes::Wait, 0));
auto responseStatus = GENERATE(ResponseMsgParamCodes::Processing, ResponseMsgParamCodes::Error, ResponseMsgParamCodes::Finished);
auto value = GENERATE(0, 1, 2, 3, 10, 11, 99, 100, 101, 102, 200, 255);
std::array<uint8_t, 8> txbuff;
uint8_t msglen = Protocol::EncodeResponseQueryOperation(requestMsg, responseStatus, value, txbuff.data());
CHECK(msglen <= 8);
CHECK(txbuff[0] == (uint8_t)requestMsg.code);
CHECK(txbuff[1] == requestMsg.value + '0');
CHECK(txbuff[2] == ' ');
CHECK(txbuff[3] == (uint8_t)responseStatus);
if (responseStatus == ResponseMsgParamCodes::Finished) {
CHECK(txbuff[4] == '\n');
CHECK(msglen == 5);
} else {
if (value < 10) {
CHECK(txbuff[4] == value + '0');
} else if (value < 100) {
CHECK(txbuff[4] == value / 10 + '0');
CHECK(txbuff[5] == value % 10 + '0');
} else {
CHECK(txbuff[4] == value / 100 + '0');
CHECK(txbuff[5] == (value / 10) % 10 + '0');
CHECK(txbuff[6] == value % 10 + '0');
}
CHECK(txbuff[msglen - 1] == '\n');
}
}
TEST_CASE("protocol::DecodeRequest", "[protocol]") {
using namespace modules;
Protocol p;
const char *rxbuff = GENERATE(
"B0\n", "B1\n", "B2\n",
"E0\n", "E1\n", "E2\n", "E3\n", "E4\n",
"K0\n",
"L0\n", "L1\n", "L2\n", "L3\n", "L4\n",
"M0\n", "M1\n",
"P0\n",
"Q0\n",
"S0\n", "S1\n", "S2\n", "S3\n",
"T0\n", "T1\n", "T2\n", "T3\n",
"U0\n",
"W0\n",
"X0\n");
const char *pc = rxbuff;
for (;;) {
uint8_t c = *pc++;
if (c == 0) {
// end of input test data
break;
} else if (c == '\n') {
// regular end of message line
CHECK(p.DecodeRequest(c) == Protocol::DecodeStatus::MessageCompleted);
} else {
CHECK(p.DecodeRequest(c) == Protocol::DecodeStatus::NeedMoreData);
}
}
// check the message type
const RequestMsg &rq = p.GetRequestMsg();
CHECK((uint8_t)rq.code == rxbuff[0]);
CHECK(rq.value == rxbuff[1] - '0');
}
TEST_CASE("protocol::DecodeResponseReadFinda", "[protocol]") {
using namespace modules;
Protocol p;
const char *rxbuff = GENERATE(
"P0 A0\n",
"P0 A1\n");
const char *pc = rxbuff;
for (;;) {
uint8_t c = *pc++;
if (c == 0) {
// end of input test data
break;
} else if (c == '\n') {
// regular end of message line
CHECK(p.DecodeResponse(c) == Protocol::DecodeStatus::MessageCompleted);
} else {
CHECK(p.DecodeResponse(c) == Protocol::DecodeStatus::NeedMoreData);
}
}
// check the message type
const ResponseMsg &rsp = p.GetResponseMsg();
CHECK((uint8_t)rsp.request.code == rxbuff[0]);
CHECK(rsp.request.value == rxbuff[1] - '0');
CHECK((uint8_t)rsp.params.code == rxbuff[3]);
CHECK((uint8_t)rsp.params.value == rxbuff[4] - '0');
}
TEST_CASE("protocol::DecodeResponseQueryOperation", "[protocol]") {
using namespace modules;
Protocol p;
const char *cmdReference = GENERATE(
"E0", "E1", "E2", "E3", "E4",
"K0",
"L0", "L1", "L2", "L3", "L4",
"T0", "T1", "T2", "T3",
"U0",
"W0");
const char *status = GENERATE(
"P0", "P1", "E0", "E1", "E9", "F");
std::string rxbuff(cmdReference);
rxbuff += ' ';
rxbuff += status;
rxbuff += '\n';
const char *pc = rxbuff.c_str();
for (;;) {
uint8_t c = *pc++;
if (c == 0) {
// end of input test data
break;
} else if (c == '\n') {
// regular end of message line
CHECK(p.DecodeResponse(c) == Protocol::DecodeStatus::MessageCompleted);
} else {
CHECK(p.DecodeResponse(c) == Protocol::DecodeStatus::NeedMoreData);
}
}
// check the message type
const ResponseMsg &rsp = p.GetResponseMsg();
CHECK((uint8_t)rsp.request.code == rxbuff[0]);
CHECK(rsp.request.value == rxbuff[1] - '0');
CHECK((uint8_t)rsp.params.code == rxbuff[3]);
if ((uint8_t)rsp.params.code != (uint8_t)ResponseMsgParamCodes::Finished) { //@@TODO again, not clean, need to define a separate msg struct for the params to make it type-safe and clean
CHECK((uint8_t)rsp.params.value == rxbuff[4] - '0');
}
}
TEST_CASE("protocol::DecodeRequestErrors", "[protocol]") {
using namespace modules;
Protocol p;
const char b0[] = "b0";
CHECK(p.DecodeRequest(b0[0]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(b0[1]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
// reset protokol decoder
CHECK(p.DecodeRequest('\n') == Protocol::DecodeStatus::MessageCompleted);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
const char B1_[] = "B1 \n";
CHECK(p.DecodeRequest(B1_[0]) == Protocol::DecodeStatus::NeedMoreData);
CHECK(p.DecodeRequest(B1_[1]) == Protocol::DecodeStatus::NeedMoreData);
CHECK(p.DecodeRequest(B1_[2]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(B1_[3]) == Protocol::DecodeStatus::MessageCompleted);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
const char _B2[] = " B2\n";
CHECK(p.DecodeRequest(_B2[0]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(_B2[1]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(_B2[2]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(_B2[3]) == Protocol::DecodeStatus::MessageCompleted);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
const char _B0_[] = " B0 ";
CHECK(p.DecodeRequest(_B0_[0]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(_B0_[1]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(_B0_[2]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest(_B0_[3]) == Protocol::DecodeStatus::Error);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
CHECK(p.DecodeRequest('\n') == Protocol::DecodeStatus::MessageCompleted);
CHECK(p.GetRequestMsg().code == RequestMsgCodes::unknown);
}
Reference in New Issue View Git Blame Copy Permalink