fsfw/unittests/cfdp/handler/testReservedMsgParser.cpp

#include <catch2/catch_test_macros.hpp>

#include "fsfw/cfdp/CfdpMessage.h"
#include "fsfw/cfdp/VarLenFields.h"
#include "fsfw/cfdp/handler/PutRequest.h"
#include "fsfw/cfdp/handler/ReservedMessageParser.h"
#include "fsfw/cfdp/tlv/Lv.h"
#include "fsfw/cfdp/tlv/ReservedMessageCreator.h"
#include "fsfw/cfdp/tlv/StringLv.h"
#include "fsfw/globalfunctions/arrayprinter.h"
#include "fsfw/serialize.h"
#include "mocks/MessageQueueMock.h"
#include "mocks/StorageManagerMock.h"

TEST_CASE("Reserved Message Parser", "[cfdp]") {
  using namespace cfdp;
  using namespace returnvalue;

  std::string srcFileName = "hello.txt";
  std::string destFileName = "hello2.txt";
  MessageQueueId_t destQueueId = 2;
  MessageQueueMock msgQueue(1);
  LocalPool::LocalPoolConfig storeCfg = {{10, 32}, {10, 64}, {10, 128}, {10, 1024}};
  StorageManagerMock ipcStore(0, storeCfg);
  std::array<uint8_t, 128> buffer{};
  uint8_t msgBuf[32]{};

  EntityId entityId(cfdp::WidthInBytes::ONE_BYTE, 5);
  uint8_t* msgBufPtr = msgBuf;
  size_t serLen = 0;
  cfdp::StringLv srcName(srcFileName);
  cfdp::StringLv destName(destFileName);
  CHECK(entityId.serializeAsLv(&msgBufPtr, &serLen, sizeof(msgBuf)) == OK);
  CHECK(srcName.serialize(&msgBufPtr, &serLen, sizeof(msgBuf), SerializeIF::Endianness::NETWORK) ==
        OK);
  CHECK(destName.serialize(&msgBufPtr, &serLen, sizeof(msgBuf), SerializeIF::Endianness::NETWORK) ==
        OK);
  ReservedMessageCreator creator(static_cast<uint8_t>(ProxyOpMessageType::PUT_REQUEST), msgBuf,
                                 serLen);
  serLen = 0;
  ReturnValue_t result = creator.serializeBe(buffer.data(), serLen, buffer.size());
  CHECK(result == returnvalue::OK);
  arrayprinter::print(buffer.data(), serLen);

  ReservedMessageParser parser(ipcStore, msgQueue, destQueueId);
  REQUIRE(parser.parse(buffer.data(), serLen) == OK);
  CommandMessage msg;
  CHECK(msgQueue.wasMessageSent());
  CHECK(msgQueue.numberOfSentMessages() == 1);
  CHECK(msgQueue.getNextSentMessage(destQueueId, msg) == OK);
  store_address_t storeId = CfdpMessage::getStoreId(&msg);
  const uint8_t* data;
  size_t packetLen;
  CHECK(ipcStore.getData(storeId, &data, &packetLen) == OK);
  CHECK(packetLen > 0);
  PutRequest putRequest;
  size_t dummy = packetLen;
  REQUIRE(putRequest.deSerialize(&data, &dummy, SerializeIF::Endianness::MACHINE) == OK);
  CHECK(putRequest.getDestId().getValue() == entityId.getValue());
  CHECK(putRequest.getDestId().getWidth() == entityId.getWidth());
  size_t sourceNameSize = 0;
  auto& sourceNameLv = putRequest.getSourceName();
  const char* sourceString = sourceNameLv.getString(sourceNameSize);
  CHECK(sourceNameSize == srcFileName.size());
  CHECK(std::strncmp(sourceString, srcFileName.c_str(), sourceNameSize) == 0);
  size_t destNameSize = 0;
  auto& destNameLv = putRequest.getDestName();
  const char* destString = destNameLv.getString(destNameSize);
  CHECK(destNameSize == destFileName.size());
  CHECK(std::strncmp(destString, destFileName.c_str(), destNameSize) == 0);
}