fsfw/unittests/mocks/MessageQueueMock.cpp

165 lines
5.2 KiB
C++
Raw Normal View History

2022-07-25 19:42:05 +02:00
#include "MessageQueueMock.h"
#include <algorithm>
#include <stdexcept>
2022-07-25 19:42:05 +02:00
MessageQueueMock::MessageQueueMock()
: MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, nullptr) {}
2022-07-25 19:42:05 +02:00
MessageQueueMock::MessageQueueMock(MessageQueueId_t queueId)
: MessageQueueBase(queueId, MessageQueueIF::NO_QUEUE, nullptr) {}
2022-07-25 19:42:05 +02:00
bool MessageQueueMock::wasMessageSent() const {
return std::any_of(
sendMap.begin(), sendMap.end(),
[](const std::pair<MessageQueueId_t, SendInfo>& pair) { return pair.second.callCount > 0; });
}
2022-07-25 19:42:05 +02:00
size_t MessageQueueMock::numberOfSentMessage() const {
size_t callCount = 0;
for (auto& destInfo : sendMap) {
callCount += destInfo.second.callCount;
}
return callCount;
}
2022-07-25 19:42:05 +02:00
size_t MessageQueueMock::numberOfSentMessage(MessageQueueId_t id) const {
auto iter = sendMap.find(id);
if (iter == sendMap.end()) {
return 0;
}
return iter->second.callCount;
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::clearLastReceivedMessage(bool clearCmdMsg) {
if (receivedMsgs.empty()) {
return MessageQueueIF::EMPTY;
}
if (clearCmdMsg) {
CommandMessage message;
std::memcpy(message.getBuffer(), receivedMsgs.front().getBuffer(), message.getMessageSize());
message.clearCommandMessage();
}
2022-07-25 19:42:05 +02:00
receivedMsgs.pop();
return HasReturnvaluesIF::RETURN_OK;
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::receiveMessage(MessageQueueMessageIF* message) {
if (receivedMsgs.empty()) {
return MessageQueueIF::EMPTY;
}
std::memcpy(message->getBuffer(), receivedMsgs.front().getBuffer(), message->getMessageSize());
2022-07-25 19:42:05 +02:00
receivedMsgs.pop();
return HasReturnvaluesIF::RETURN_OK;
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::flush(uint32_t* count) { return HasReturnvaluesIF::RETURN_FAILED; }
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::sendMessageFrom(MessageQueueId_t sendTo,
MessageQueueMessageIF* message,
MessageQueueId_t sentFrom, bool ignoreFault) {
if (message == nullptr) {
return HasReturnvaluesIF::RETURN_FAILED;
}
2022-07-25 14:31:57 +02:00
auto iter = sendMap.find(sendTo);
MessageQueueMessage messageCopy;
2022-07-25 14:31:57 +02:00
if (iter == sendMap.end()) {
createMsgCopy(messageCopy, *message);
sendMap.emplace(sendTo, SendInfo(messageCopy, 1));
2022-07-25 14:31:57 +02:00
} else {
iter->second.callCount += 1;
createMsgCopy(messageCopy, *message);
2022-07-25 19:42:05 +02:00
iter->second.msgs.push(messageCopy);
2022-07-25 14:31:57 +02:00
}
return HasReturnvaluesIF::RETURN_OK;
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::reply(MessageQueueMessageIF* message) {
return sendMessageFrom(MessageQueueIF::NO_QUEUE, message, this->getId(), false);
}
2022-07-25 19:42:05 +02:00
void MessageQueueMock::clearMessages(bool clearCommandMessages) {
if (not clearCommandMessages) {
sendMap.clear();
return;
2022-07-25 14:31:57 +02:00
}
for (auto& destInfo : sendMap) {
2022-07-25 19:42:05 +02:00
while (!destInfo.second.msgs.empty()) {
CommandMessage message;
std::memcpy(message.getBuffer(), destInfo.second.msgs.front().getBuffer(),
message.getMessageSize());
message.clear();
2022-07-25 19:42:05 +02:00
destInfo.second.msgs.pop();
destInfo.second.callCount--;
}
}
sendMap.clear();
}
2022-07-25 19:42:05 +02:00
void MessageQueueMock::addReceivedMessage(MessageQueueMessageIF& msg) {
MessageQueueMessage messageCopy;
createMsgCopy(messageCopy, msg);
2022-07-25 19:42:05 +02:00
receivedMsgs.push(messageCopy);
}
2022-07-25 19:42:05 +02:00
void MessageQueueMock::createMsgCopy(MessageQueueMessageIF& into, MessageQueueMessageIF& from) {
if (from.getMessageSize() > into.getMaximumDataSize()) {
throw std::invalid_argument("Passed message does not fit into message copy");
}
std::memcpy(into.getBuffer(), from.getBuffer(), from.getMaximumDataSize());
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::getNextSentMessage(MessageQueueId_t id,
MessageQueueMessageIF& message) {
auto iter = sendMap.find(id);
if (iter == sendMap.end() or iter->second.callCount == 0) {
return MessageQueueIF::EMPTY;
}
createMsgCopy(message, iter->second.msgs.front());
return HasReturnvaluesIF::RETURN_OK;
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::getNextSentMessage(MessageQueueMessageIF& message) {
return getNextSentMessage(MessageQueueBase::getDefaultDestination(), message);
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::clearLastSentMessage(MessageQueueId_t destId, bool clearCmdMsg) {
auto iter = sendMap.find(destId);
if (iter == sendMap.end()) {
return MessageQueueIF::EMPTY;
}
return clearLastSentMessage(iter, clearCmdMsg);
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::clearLastSentMessage(bool clearCmdMsg) {
auto iter = sendMap.find(getDefaultDestination());
if (iter == sendMap.end()) {
return MessageQueueIF::EMPTY;
}
ReturnValue_t result = clearLastSentMessage(iter, clearCmdMsg);
clearEmptyEntries();
return result;
}
2022-07-25 19:42:05 +02:00
ReturnValue_t MessageQueueMock::clearLastSentMessage(
std::map<MessageQueueId_t, SendInfo>::iterator& iter, bool clearCmdMsg) {
if (clearCmdMsg) {
CommandMessage message;
std::memcpy(message.getBuffer(), iter->second.msgs.front().getBuffer(),
message.getMessageSize());
message.clear();
}
2022-07-25 19:42:05 +02:00
iter->second.msgs.pop();
iter->second.callCount--;
return HasReturnvaluesIF::RETURN_OK;
}
2022-07-25 19:42:05 +02:00
void MessageQueueMock::clearEmptyEntries() {
for (auto it = sendMap.cbegin(); it != sendMap.cend();) {
if (it->second.callCount == 0) {
sendMap.erase(it++);
} else {
++it;
}
}
}