eive/fsfw
eive/fsfw
15
1
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases 1 Wiki Activity

CFDP FSFW Integration #111

Merged
muellerr merged 170 commits from cfdp-integration into develop 2022-09-16 11:11:22 +02:00
Conversation 0 Commits 170 Files Changed 293 +205 -180
13 changed files with 205 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 683cf8a047 - Show all commits

3
src/fsfw/cfdp/CfdpDistributor.cpp
View File

@ -21,7 +21,8 @@ ReturnValue_t CfdpDistributor::selectDestination(MessageQueueId_t& destId) {
if (accessorPair.first != returnvalue::OK) { if (accessorPair.first != returnvalue::OK) {
return accessorPair.first; return accessorPair.first;
} }
ReturnValue_t result = pduReader.setData(accessorPair.second.data(), accessorPair.second.size()); ReturnValue_t result =
pduReader.setReadOnlyData(accessorPair.second.data(), accessorPair.second.size());
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }

4
src/fsfw/cfdp/CfdpDistributor.h
View File

@ -4,7 +4,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "fsfw/cfdp/pdu/HeaderReader.h" #include "fsfw/cfdp/pdu/PduHeaderReader.h"
#include "fsfw/returnvalues/returnvalue.h" #include "fsfw/returnvalues/returnvalue.h"
#include "fsfw/tcdistribution/CfdpPacketChecker.h" #include "fsfw/tcdistribution/CfdpPacketChecker.h"
#include "fsfw/tcdistribution/TcDistributorBase.h" #include "fsfw/tcdistribution/TcDistributorBase.h"
@ -60,7 +60,7 @@ class CfdpDistributor : public TcDistributorBase, public AcceptsTelecommandsIF {
const char* name; const char* name;
MessageQueueId_t queueId; MessageQueueId_t queueId;
}; };
HeaderReader pduReader; PduHeaderReader pduReader;
ReturnValue_t lastTcError = returnvalue::OK; ReturnValue_t lastTcError = returnvalue::OK;
ReturnValue_t lastTmError = returnvalue::OK; ReturnValue_t lastTmError = returnvalue::OK;
// I don't think a regular OBSW will have more than 1 or 2 of these destinations, so I think // I don't think a regular OBSW will have more than 1 or 2 of these destinations, so I think

6
src/fsfw/cfdp/handler/DestHandler.cpp
View File

@ -8,7 +8,7 @@
#include "fsfw/cfdp/pdu/EofPduReader.h" #include "fsfw/cfdp/pdu/EofPduReader.h"
#include "fsfw/cfdp/pdu/FileDataReader.h" #include "fsfw/cfdp/pdu/FileDataReader.h"
#include "fsfw/cfdp/pdu/FinishedPduCreator.h" #include "fsfw/cfdp/pdu/FinishedPduCreator.h"
#include "fsfw/cfdp/pdu/HeaderReader.h" #include "fsfw/cfdp/pdu/PduHeaderReader.h"
#include "fsfw/objectmanager.h" #include "fsfw/objectmanager.h"
#include "fsfw/tmtcservices/TmTcMessage.h" #include "fsfw/tmtcservices/TmTcMessage.h"
@ -236,7 +236,7 @@ ReturnValue_t cfdp::DestHandler::handleMetadataParseError(ReturnValue_t result,
sif::warning << "Parsing Metadata PDU failed with code " << result << std::endl; sif::warning << "Parsing Metadata PDU failed with code " << result << std::endl;
#else #else
#endif #endif
HeaderReader headerReader(rawData, maxSize); PduHeaderReader headerReader(rawData, maxSize);
result = headerReader.parseData(); result = headerReader.parseData();
if (result != OK) { if (result != OK) {
// TODO: Now this really should not happen. Warning or error, // TODO: Now this really should not happen. Warning or error,
@ -461,3 +461,5 @@ void cfdp::DestHandler::setMsgQueue(MessageQueueIF& queue) { fp.msgQueue = &queu
void cfdp::DestHandler::setEventReporter(EventReportingProxyIF& reporter) { void cfdp::DestHandler::setEventReporter(EventReportingProxyIF& reporter) {
fp.eventReporter = &reporter; fp.eventReporter = &reporter;
} }
const cfdp::DestHandlerParams& cfdp::DestHandler::getDestHandlerParams() const { return dp; }

1
src/fsfw/cfdp/handler/DestHandler.h
View File

@ -126,6 +126,7 @@ class DestHandler {
[[nodiscard]] CfdpStates getCfdpState() const; [[nodiscard]] CfdpStates getCfdpState() const;
[[nodiscard]] TransactionStep getTransactionStep() const; [[nodiscard]] TransactionStep getTransactionStep() const;
[[nodiscard]] const TransactionId& getTransactionId() const; [[nodiscard]] const TransactionId& getTransactionId() const;
[[nodiscard]] const DestHandlerParams& getDestHandlerParams() const;
private: private:
struct TransactionParams { struct TransactionParams {

8
src/fsfw/cfdp/pdu/FileDataReader.cpp
View File

@ -1,16 +1,16 @@
#include "FileDataReader.h" #include "FileDataReader.h"
FileDataReader::FileDataReader(const uint8_t* pduBuf, size_t maxSize, FileDataInfo& info) FileDataReader::FileDataReader(const uint8_t* pduBuf, size_t maxSize, FileDataInfo& info)
: HeaderReader(pduBuf, maxSize), info(info) {} : PduHeaderReader(pduBuf, maxSize), info(info) {}
ReturnValue_t FileDataReader::parseData() { ReturnValue_t FileDataReader::parseData() {
ReturnValue_t result = HeaderReader::parseData(); ReturnValue_t result = PduHeaderReader::parseData();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
size_t currentIdx = HeaderReader::getHeaderSize(); size_t currentIdx = PduHeaderReader::getHeaderSize();
const uint8_t* buf = pointers.rawPtr + currentIdx; const uint8_t* buf = pointers.rawPtr + currentIdx;
size_t remSize = HeaderReader::getWholePduSize() - currentIdx; size_t remSize = PduHeaderReader::getWholePduSize() - currentIdx;
if (remSize < 1) { if (remSize < 1) {
return SerializeIF::STREAM_TOO_SHORT; return SerializeIF::STREAM_TOO_SHORT;
} }

4
src/fsfw/cfdp/pdu/FileDataReader.h
View File

@ -3,9 +3,9 @@
#include "../definitions.h" #include "../definitions.h"
#include "FileDataInfo.h" #include "FileDataInfo.h"
#include "HeaderReader.h" #include "PduHeaderReader.h"
class FileDataReader : public HeaderReader { class FileDataReader : public PduHeaderReader {
public: public:
FileDataReader(const uint8_t* pduBuf, size_t maxSize, FileDataInfo& info); FileDataReader(const uint8_t* pduBuf, size_t maxSize, FileDataInfo& info);

8
src/fsfw/cfdp/pdu/FileDirectiveReader.cpp
View File

@ -1,12 +1,12 @@
#include "FileDirectiveReader.h" #include "FileDirectiveReader.h"
FileDirectiveReader::FileDirectiveReader(const uint8_t *pduBuf, size_t maxSize) FileDirectiveReader::FileDirectiveReader(const uint8_t *pduBuf, size_t maxSize)
: HeaderReader(pduBuf, maxSize) {} : PduHeaderReader(pduBuf, maxSize) {}
cfdp::FileDirectives FileDirectiveReader::getFileDirective() const { return fileDirective; } cfdp::FileDirectives FileDirectiveReader::getFileDirective() const { return fileDirective; }
ReturnValue_t FileDirectiveReader::parseData() { ReturnValue_t FileDirectiveReader::parseData() {
ReturnValue_t result = HeaderReader::parseData(); ReturnValue_t result = PduHeaderReader::parseData();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -16,7 +16,7 @@ ReturnValue_t FileDirectiveReader::parseData() {
if (FileDirectiveReader::getWholePduSize() > maxSize) { if (FileDirectiveReader::getWholePduSize() > maxSize) {
return SerializeIF::STREAM_TOO_SHORT; return SerializeIF::STREAM_TOO_SHORT;
} }
size_t currentIdx = HeaderReader::getHeaderSize(); size_t currentIdx = PduHeaderReader::getHeaderSize();
if (not checkFileDirective(pointers.rawPtr[currentIdx])) { if (not checkFileDirective(pointers.rawPtr[currentIdx])) {
return cfdp::INVALID_DIRECTIVE_FIELDS; return cfdp::INVALID_DIRECTIVE_FIELDS;
} }
@ -26,7 +26,7 @@ ReturnValue_t FileDirectiveReader::parseData() {
size_t FileDirectiveReader::getHeaderSize() const { size_t FileDirectiveReader::getHeaderSize() const {
// return size of header plus the directive byte // return size of header plus the directive byte
return HeaderReader::getHeaderSize() + 1; return PduHeaderReader::getHeaderSize() + 1;
} }
bool FileDirectiveReader::checkFileDirective(uint8_t rawByte) { bool FileDirectiveReader::checkFileDirective(uint8_t rawByte) {

4
src/fsfw/cfdp/pdu/FileDirectiveReader.h
View File

@ -2,7 +2,7 @@
#define FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVEDESERIALIZER_H_ #define FSFW_SRC_FSFW_CFDP_PDU_FILEDIRECTIVEDESERIALIZER_H_
#include "../definitions.h" #include "../definitions.h"
#include "fsfw/cfdp/pdu/HeaderReader.h" #include "fsfw/cfdp/pdu/PduHeaderReader.h"
/** /**
* @brief This class is used to deserialize a PDU file directive header from raw memory. * @brief This class is used to deserialize a PDU file directive header from raw memory.
@ -11,7 +11,7 @@
* This is a zero-copy implementation and #parseData needs to be called to ensure the data is * This is a zero-copy implementation and #parseData needs to be called to ensure the data is
* valid. * valid.
*/ */
class FileDirectiveReader : public HeaderReader { class FileDirectiveReader : public PduHeaderReader {
public: public:
FileDirectiveReader(const uint8_t* pduBuf, size_t maxSize); FileDirectiveReader(const uint8_t* pduBuf, size_t maxSize);

67
src/fsfw/cfdp/pdu/HeaderReader.cpp
View File

@ -1,12 +1,14 @@
#include "HeaderReader.h"
#include <fsfw/serialize/SerializeAdapter.h> #include <fsfw/serialize/SerializeAdapter.h>
#include <cstring> #include <cstring>
HeaderReader::HeaderReader(const uint8_t *pduBuf, size_t maxSize) { setData(pduBuf, maxSize); } #include "PduHeaderReader.h"
ReturnValue_t HeaderReader::parseData() { PduHeaderReader::PduHeaderReader(const uint8_t *pduBuf, size_t maxSize) {
setReadOnlyData(pduBuf, maxSize);
}
ReturnValue_t PduHeaderReader::parseData() {
if (pointers.rawPtr == nullptr) { if (pointers.rawPtr == nullptr) {
return returnvalue::FAILED; return returnvalue::FAILED;
} }
@ -20,10 +22,15 @@ ReturnValue_t HeaderReader::parseData() {
cfdp::WidthInBytes widthSeqNum = getLenSeqNum(); cfdp::WidthInBytes widthSeqNum = getLenSeqNum();
seqNumRaw = static_cast<uint8_t *>(sourceIdRaw) + static_cast<uint8_t>(widthEntityIds); seqNumRaw = static_cast<uint8_t *>(sourceIdRaw) + static_cast<uint8_t>(widthEntityIds);
destIdRaw = static_cast<uint8_t *>(seqNumRaw) + static_cast<uint8_t>(widthSeqNum); destIdRaw = static_cast<uint8_t *>(seqNumRaw) + static_cast<uint8_t>(widthSeqNum);
if (getWholePduSize() > PduHeaderReader::getHeaderSize()) {
pointers.dataFieldStart = reinterpret_cast<const uint8_t *>(destIdRaw) + widthEntityIds;
} else {
pointers.dataFieldStart = nullptr;
}
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t HeaderReader::setData(uint8_t *dataPtr, size_t maxSize_, void *args) { ReturnValue_t PduHeaderReader::setData(uint8_t *dataPtr, size_t maxSize_, void *args) {
if (dataPtr == nullptr) { if (dataPtr == nullptr) {
return returnvalue::FAILED; return returnvalue::FAILED;
} }
@ -35,68 +42,68 @@ ReturnValue_t HeaderReader::setData(uint8_t *dataPtr, size_t maxSize_, void *arg
return returnvalue::OK; return returnvalue::OK;
} }
size_t HeaderReader::getHeaderSize() const { size_t PduHeaderReader::getHeaderSize() const {
if (pointers.fixedHeader != nullptr) { if (pointers.fixedHeader != nullptr) {
return getLenEntityIds() * 2 + getLenSeqNum() + 4; return getLenEntityIds() * 2 + getLenSeqNum() + 4;
} }
return 0; return 0;
} }
size_t HeaderReader::getPduDataFieldLen() const { size_t PduHeaderReader::getPduDataFieldLen() const {
return (pointers.fixedHeader->pduDataFieldLenH << 8) | pointers.fixedHeader->pduDataFieldLenL; return (pointers.fixedHeader->pduDataFieldLenH << 8) | pointers.fixedHeader->pduDataFieldLenL;
} }
size_t HeaderReader::getWholePduSize() const { size_t PduHeaderReader::getWholePduSize() const {
return getPduDataFieldLen() + HeaderReader::getHeaderSize(); return getPduDataFieldLen() + PduHeaderReader::getHeaderSize();
} }
cfdp::PduType HeaderReader::getPduType() const { cfdp::PduType PduHeaderReader::getPduType() const {
return static_cast<cfdp::PduType>((pointers.fixedHeader->firstByte >> 4) & 0x01); return static_cast<cfdp::PduType>((pointers.fixedHeader->firstByte >> 4) & 0x01);
} }
cfdp::Direction HeaderReader::getDirection() const { cfdp::Direction PduHeaderReader::getDirection() const {
return static_cast<cfdp::Direction>((pointers.fixedHeader->firstByte >> 3) & 0x01); return static_cast<cfdp::Direction>((pointers.fixedHeader->firstByte >> 3) & 0x01);
} }
cfdp::TransmissionModes HeaderReader::getTransmissionMode() const { cfdp::TransmissionModes PduHeaderReader::getTransmissionMode() const {
return static_cast<cfdp::TransmissionModes>((pointers.fixedHeader->firstByte >> 2) & 0x01); return static_cast<cfdp::TransmissionModes>((pointers.fixedHeader->firstByte >> 2) & 0x01);
} }
bool HeaderReader::getCrcFlag() const { return (pointers.fixedHeader->firstByte >> 1) & 0x01; } bool PduHeaderReader::getCrcFlag() const { return (pointers.fixedHeader->firstByte >> 1) & 0x01; }
bool HeaderReader::getLargeFileFlag() const { return pointers.fixedHeader->firstByte & 0x01; } bool PduHeaderReader::getLargeFileFlag() const { return pointers.fixedHeader->firstByte & 0x01; }
cfdp::SegmentationControl HeaderReader::getSegmentationControl() const { cfdp::SegmentationControl PduHeaderReader::getSegmentationControl() const {
return static_cast<cfdp::SegmentationControl>((pointers.fixedHeader->fourthByte >> 7) & 0x01); return static_cast<cfdp::SegmentationControl>((pointers.fixedHeader->fourthByte >> 7) & 0x01);
} }
cfdp::WidthInBytes HeaderReader::getLenEntityIds() const { cfdp::WidthInBytes PduHeaderReader::getLenEntityIds() const {
return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte >> 4) & 0x07); return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte >> 4) & 0x07);
} }
cfdp::WidthInBytes HeaderReader::getLenSeqNum() const { cfdp::WidthInBytes PduHeaderReader::getLenSeqNum() const {
return static_cast<cfdp::WidthInBytes>(pointers.fixedHeader->fourthByte & 0x07); return static_cast<cfdp::WidthInBytes>(pointers.fixedHeader->fourthByte & 0x07);
} }
cfdp::SegmentMetadataFlag HeaderReader::getSegmentMetadataFlag() const { cfdp::SegmentMetadataFlag PduHeaderReader::getSegmentMetadataFlag() const {
return static_cast<cfdp::SegmentMetadataFlag>((pointers.fixedHeader->fourthByte >> 3) & 0x01); return static_cast<cfdp::SegmentMetadataFlag>((pointers.fixedHeader->fourthByte >> 3) & 0x01);
} }
void HeaderReader::getSourceId(cfdp::EntityId &sourceId) const { void PduHeaderReader::getSourceId(cfdp::EntityId &sourceId) const {
assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&sourceId), getLenEntityIds(), assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&sourceId), getLenEntityIds(),
this->sourceIdRaw); this->sourceIdRaw);
} }
void HeaderReader::getDestId(cfdp::EntityId &destId) const { void PduHeaderReader::getDestId(cfdp::EntityId &destId) const {
assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&destId), getLenEntityIds(), this->destIdRaw); assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&destId), getLenEntityIds(), this->destIdRaw);
} }
void HeaderReader::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) const { void PduHeaderReader::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) const {
assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&seqNum), getLenSeqNum(), this->seqNumRaw); assignVarLenField(dynamic_cast<cfdp::VarLenField *>(&seqNum), getLenSeqNum(), this->seqNumRaw);
} }
void HeaderReader::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInBytes width, void PduHeaderReader::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInBytes width,
void *sourcePtr) const { void *sourcePtr) const {
switch (width) { switch (width) {
case (cfdp::WidthInBytes::ONE_BYTE): { case (cfdp::WidthInBytes::ONE_BYTE): {
auto *fieldTyped = static_cast<uint8_t *>(sourcePtr); auto *fieldTyped = static_cast<uint8_t *>(sourcePtr);
@ -122,25 +129,25 @@ void HeaderReader::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInByte
} }
} }
size_t HeaderReader::getMaxSize() const { return maxSize; } size_t PduHeaderReader::getMaxSize() const { return maxSize; }
bool HeaderReader::hasSegmentMetadataFlag() const { bool PduHeaderReader::hasSegmentMetadataFlag() const {
if (this->getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT) { if (this->getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT) {
return true; return true;
} }
return false; return false;
} }
ReturnValue_t HeaderReader::setData(const uint8_t *dataPtr, size_t maxSize_) { ReturnValue_t PduHeaderReader::setReadOnlyData(const uint8_t *dataPtr, size_t maxSize_) {
return setData(const_cast<uint8_t *>(dataPtr), maxSize_, nullptr); return setData(const_cast<uint8_t *>(dataPtr), maxSize_, nullptr);
} }
bool HeaderReader::isNull() const { bool PduHeaderReader::isNull() const {
return pointers.rawPtr == nullptr or pointers.fixedHeader == nullptr; return pointers.rawPtr == nullptr or pointers.fixedHeader == nullptr;
} }
HeaderReader::operator bool() const { return not isNull(); } PduHeaderReader::operator bool() const { return not isNull(); }
void HeaderReader::fillConfig(PduConfig &cfg) const { void PduHeaderReader::fillConfig(PduConfig &cfg) const {
cfg.largeFile = getLargeFileFlag(); cfg.largeFile = getLargeFileFlag();
cfg.crcFlag = getCrcFlag(); cfg.crcFlag = getCrcFlag();
cfg.mode = getTransmissionMode(); cfg.mode = getTransmissionMode();
@ -149,3 +156,5 @@ void HeaderReader::fillConfig(PduConfig &cfg) const {
getSourceId(cfg.sourceId); getSourceId(cfg.sourceId);
getDestId(cfg.destId); getDestId(cfg.destId);
} }
const uint8_t *PduHeaderReader::getPduDataField() const { return pointers.dataFieldStart; }

13
src/fsfw/cfdp/pdu/HeaderReader.h → src/fsfw/cfdp/pdu/PduHeaderReader.h
View File

@ -23,16 +23,16 @@ struct PduHeaderFixedStruct {
* This is a zero-copy implementation and #parseData needs to be called to ensure the data is * This is a zero-copy implementation and #parseData needs to be called to ensure the data is
* valid. * valid.
*/ */
class HeaderReader : public RedirectableDataPointerIF, public PduHeaderIF { class PduHeaderReader : public RedirectableDataPointerIF, public PduHeaderIF {
public: public:
HeaderReader() = default; PduHeaderReader() = default;
/** /**
* Initialize a PDU header from raw data. This is a zero-copy implementation and #parseData * Initialize a PDU header from raw data. This is a zero-copy implementation and #parseData
* needs to be called to ensure the data is valid * needs to be called to ensure the data is valid
* @param pduBuf * @param pduBuf
* @param maxSize * @param maxSize
*/ */
HeaderReader(const uint8_t* pduBuf, size_t maxSize); PduHeaderReader(const uint8_t* pduBuf, size_t maxSize);
/** /**
* This needs to be called before accessing the PDU fields to avoid segmentation faults. * This needs to be called before accessing the PDU fields to avoid segmentation faults.
@ -74,6 +74,7 @@ class HeaderReader : public RedirectableDataPointerIF, public PduHeaderIF {
ReturnValue_t deserResult = returnvalue::OK; ReturnValue_t deserResult = returnvalue::OK;
[[nodiscard]] size_t getMaxSize() const; [[nodiscard]] size_t getMaxSize() const;
[[nodiscard]] const uint8_t* getPduDataField() const;
/** /**
* Can also be used to reset the pointer to a nullptr, but the getter functions will not * Can also be used to reset the pointer to a nullptr, but the getter functions will not
@ -83,11 +84,12 @@ class HeaderReader : public RedirectableDataPointerIF, public PduHeaderIF {
* @param args * @param args
* @return * @return
*/ */
ReturnValue_t setData(const uint8_t* dataPtr, size_t maxSize); ReturnValue_t setReadOnlyData(const uint8_t* dataPtr, size_t maxSize);
protected: protected:
struct Pointers { struct Pointers {
PduHeaderFixedStruct* fixedHeader = nullptr; PduHeaderFixedStruct* fixedHeader = nullptr;
const uint8_t* dataFieldStart = nullptr;
const uint8_t* rawPtr = nullptr; const uint8_t* rawPtr = nullptr;
}; };
@ -96,8 +98,7 @@ class HeaderReader : public RedirectableDataPointerIF, public PduHeaderIF {
private: private:
/** /**
* Can also be used to reset the pointer to a nullptr, but the getter functions will not * This is a reader class and setting mutable data is forbidden. Use @setReadOnlyData instead.
* perform nullptr checks!
* @param dataPtr * @param dataPtr
* @param maxSize * @param maxSize
* @param args * @param args

253
unittests/cfdp/pdu/testCfdpHeader.cpp
View File

@ -1,10 +1,14 @@
#include <array> #include <array>
#include <catch2/catch_test_macros.hpp> #include <catch2/catch_test_macros.hpp>
#include "fsfw/cfdp/pdu/FinishedInfo.h"
#include "fsfw/cfdp/pdu/FinishedPduCreator.h"
#include "fsfw/cfdp/pdu/HeaderCreator.h" #include "fsfw/cfdp/pdu/HeaderCreator.h"
#include "fsfw/cfdp/pdu/HeaderReader.h" #include "fsfw/cfdp/pdu/PduHeaderReader.h"
#include "fsfw/returnvalues/returnvalue.h" #include "fsfw/returnvalues/returnvalue.h"
using namespace returnvalue;
TEST_CASE("CFDP Header", "[cfdp]") { TEST_CASE("CFDP Header", "[cfdp]") {
using namespace cfdp; using namespace cfdp;
std::array<uint8_t, 32> serBuf{}; std::array<uint8_t, 32> serBuf{};
@ -17,63 +21,62 @@ TEST_CASE("CFDP Header", "[cfdp]") {
uint8_t* serTarget = serBuf.data(); uint8_t* serTarget = serBuf.data();
const uint8_t* deserTarget = serTarget; const uint8_t* deserTarget = serTarget;
size_t serSize = 0; size_t serSize = 0;
auto headerSerializer = HeaderCreator(pduConf, cfdp::PduType::FILE_DIRECTIVE, 0); auto creator = HeaderCreator(pduConf, cfdp::PduType::FILE_DIRECTIVE, 0);
SECTION("Header State") { SECTION("Header State") {
REQUIRE(seqNum.getSerializedSize() == 1); REQUIRE(seqNum.getSerializedSize() == 1);
REQUIRE(headerSerializer.getPduDataFieldLen() == 0); REQUIRE(creator.getPduDataFieldLen() == 0);
REQUIRE(headerSerializer.getSerializedSize() == 7); REQUIRE(creator.getSerializedSize() == 7);
REQUIRE(headerSerializer.getWholePduSize() == 7); REQUIRE(creator.getWholePduSize() == 7);
REQUIRE(headerSerializer.getCrcFlag() == false); REQUIRE(creator.getCrcFlag() == false);
REQUIRE(headerSerializer.getDirection() == cfdp::Direction::TOWARDS_RECEIVER); REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_RECEIVER);
REQUIRE(headerSerializer.getLargeFileFlag() == false); REQUIRE(creator.getLargeFileFlag() == false);
REQUIRE(headerSerializer.getLenEntityIds() == 1); REQUIRE(creator.getLenEntityIds() == 1);
REQUIRE(headerSerializer.getLenSeqNum() == 1); REQUIRE(creator.getLenSeqNum() == 1);
REQUIRE(headerSerializer.getPduType() == cfdp::PduType::FILE_DIRECTIVE); REQUIRE(creator.getPduType() == cfdp::PduType::FILE_DIRECTIVE);
REQUIRE(headerSerializer.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT); REQUIRE(creator.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
REQUIRE(headerSerializer.getSegmentationControl() == false); REQUIRE(creator.getSegmentationControl() == false);
REQUIRE(headerSerializer.getTransmissionMode() == cfdp::TransmissionModes::ACKNOWLEDGED); REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionModes::ACKNOWLEDGED);
cfdp::TransactionSeqNum seqNumLocal; cfdp::TransactionSeqNum seqNumLocal;
headerSerializer.getTransactionSeqNum(seqNumLocal); creator.getTransactionSeqNum(seqNumLocal);
REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::ONE_BYTE); REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
REQUIRE(seqNumLocal.getValue() == 2); REQUIRE(seqNumLocal.getValue() == 2);
cfdp::EntityId sourceDestId; cfdp::EntityId sourceDestId;
headerSerializer.getSourceId(sourceDestId); creator.getSourceId(sourceDestId);
REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE); REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
REQUIRE(sourceDestId.getValue() == 0); REQUIRE(sourceDestId.getValue() == 0);
headerSerializer.getDestId(sourceDestId); creator.getDestId(sourceDestId);
REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE); REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
REQUIRE(sourceDestId.getValue() == 1); REQUIRE(sourceDestId.getValue() == 1);
} }
SECTION("Deserialization fails") { SECTION("Deserialization fails") {
const uint8_t** dummyPtr = nullptr; const uint8_t** dummyPtr = nullptr;
REQUIRE(headerSerializer.deSerialize(dummyPtr, &serSize, SerializeIF::Endianness::NETWORK) == REQUIRE(creator.deSerialize(dummyPtr, &serSize, SerializeIF::Endianness::NETWORK) ==
returnvalue::FAILED); returnvalue::FAILED);
} }
SECTION("Serialization fails") { SECTION("Serialization fails") {
REQUIRE(headerSerializer.serialize(nullptr, &serSize, serBuf.size(), REQUIRE(creator.serialize(nullptr, &serSize, serBuf.size(), SerializeIF::Endianness::NETWORK) ==
SerializeIF::Endianness::NETWORK) == returnvalue::FAILED); returnvalue::FAILED);
} }
SECTION("Buffer Too Short") { SECTION("Buffer Too Short") {
for (uint8_t idx = 0; idx < 7; idx++) { for (uint8_t idx = 0; idx < 7; idx++) {
result = headerSerializer.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG); result = creator.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG);
REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT)); REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
} }
} }
SECTION("Set Data Field Len") { SECTION("Set Data Field Len") {
// Set PDU data field len // Set PDU data field len
headerSerializer.setPduDataFieldLen(0x0ff0); creator.setPduDataFieldLen(0x0ff0);
REQUIRE(headerSerializer.getPduDataFieldLen() == 0x0ff0); REQUIRE(creator.getPduDataFieldLen() == 0x0ff0);
REQUIRE(headerSerializer.getSerializedSize() == 7); REQUIRE(creator.getSerializedSize() == 7);
REQUIRE(headerSerializer.getWholePduSize() == 7 + 0x0ff0); REQUIRE(creator.getWholePduSize() == 7 + 0x0ff0);
serTarget = serBuf.data(); serTarget = serBuf.data();
serSize = 0; serSize = 0;
result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(), result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
SerializeIF::Endianness::BIG);
REQUIRE(serBuf[1] == 0x0f); REQUIRE(serBuf[1] == 0x0f);
REQUIRE(serBuf[2] == 0xf0); REQUIRE(serBuf[2] == 0xf0);
} }
@ -83,28 +86,27 @@ TEST_CASE("CFDP Header", "[cfdp]") {
pduConf.largeFile = true; pduConf.largeFile = true;
pduConf.direction = cfdp::Direction::TOWARDS_SENDER; pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
pduConf.mode = cfdp::TransmissionModes::UNACKNOWLEDGED; pduConf.mode = cfdp::TransmissionModes::UNACKNOWLEDGED;
headerSerializer.setSegmentationControl( creator.setSegmentationControl(cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION); creator.setPduType(cfdp::PduType::FILE_DATA);
headerSerializer.setPduType(cfdp::PduType::FILE_DATA); creator.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
headerSerializer.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
serTarget = serBuf.data(); serTarget = serBuf.data();
serSize = 0; serSize = 0;
SECTION("Regular") { SECTION("Regular") {
// Everything except version bit flipped to one now // Everything except version bit flipped to one now
REQUIRE(headerSerializer.serialize(&serTarget, &serSize, serBuf.size(), REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(),
SerializeIF::Endianness::BIG) == returnvalue::OK); SerializeIF::Endianness::BIG) == returnvalue::OK);
CHECK(serBuf[0] == 0x3f); CHECK(serBuf[0] == 0x3f);
CHECK(serBuf[3] == 0x99); CHECK(serBuf[3] == 0x99);
REQUIRE(headerSerializer.getCrcFlag() == true); REQUIRE(creator.getCrcFlag() == true);
REQUIRE(headerSerializer.getDirection() == cfdp::Direction::TOWARDS_SENDER); REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_SENDER);
REQUIRE(headerSerializer.getLargeFileFlag() == true); REQUIRE(creator.getLargeFileFlag() == true);
REQUIRE(headerSerializer.getLenEntityIds() == 1); REQUIRE(creator.getLenEntityIds() == 1);
REQUIRE(headerSerializer.getLenSeqNum() == 1); REQUIRE(creator.getLenSeqNum() == 1);
REQUIRE(headerSerializer.getPduType() == cfdp::PduType::FILE_DATA); REQUIRE(creator.getPduType() == cfdp::PduType::FILE_DATA);
REQUIRE(headerSerializer.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT); REQUIRE(creator.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
REQUIRE(headerSerializer.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED); REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED);
REQUIRE(headerSerializer.getSegmentationControl() == true); REQUIRE(creator.getSegmentationControl() == true);
} }
SECTION("Other variable sized fields") { SECTION("Other variable sized fields") {
@ -112,18 +114,18 @@ TEST_CASE("CFDP Header", "[cfdp]") {
pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00); pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00);
pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff); pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff);
REQUIRE(pduConf.sourceId.getSerializedSize() == 4); REQUIRE(pduConf.sourceId.getSerializedSize() == 4);
REQUIRE(headerSerializer.getSerializedSize() == 14); REQUIRE(creator.getSerializedSize() == 14);
REQUIRE(headerSerializer.serialize(&serTarget, &serSize, serBuf.size(), REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(),
SerializeIF::Endianness::BIG) == returnvalue::OK); SerializeIF::Endianness::BIG) == returnvalue::OK);
REQUIRE(headerSerializer.getCrcFlag() == true); REQUIRE(creator.getCrcFlag() == true);
REQUIRE(headerSerializer.getDirection() == cfdp::Direction::TOWARDS_SENDER); REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_SENDER);
REQUIRE(headerSerializer.getLargeFileFlag() == true); REQUIRE(creator.getLargeFileFlag() == true);
REQUIRE(headerSerializer.getLenEntityIds() == 4); REQUIRE(creator.getLenEntityIds() == 4);
REQUIRE(headerSerializer.getLenSeqNum() == 2); REQUIRE(creator.getLenSeqNum() == 2);
REQUIRE(headerSerializer.getPduType() == cfdp::PduType::FILE_DATA); REQUIRE(creator.getPduType() == cfdp::PduType::FILE_DATA);
REQUIRE(headerSerializer.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT); REQUIRE(creator.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
REQUIRE(headerSerializer.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED); REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED);
REQUIRE(headerSerializer.getSegmentationControl() == true); REQUIRE(creator.getSegmentationControl() == true);
// Last three bits are 2 now (length of seq number) and bit 1 to bit 3 is 4 (len entity IDs) // Last three bits are 2 now (length of seq number) and bit 1 to bit 3 is 4 (len entity IDs)
REQUIRE(serBuf[3] == 0b11001010); REQUIRE(serBuf[3] == 0b11001010);
uint32_t entityId = 0; uint32_t entityId = 0;
@ -148,9 +150,8 @@ TEST_CASE("CFDP Header", "[cfdp]") {
pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00); pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00);
pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff); pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff);
for (uint8_t idx = 0; idx < 14; idx++) { for (uint8_t idx = 0; idx < 14; idx++) {
REQUIRE( REQUIRE(creator.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG) ==
headerSerializer.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG) == SerializeIF::BUFFER_TOO_SHORT);
SerializeIF::BUFFER_TOO_SHORT);
} }
} }
} }
@ -165,8 +166,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
} }
SECTION("Header Serialization") { SECTION("Header Serialization") {
result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(), result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
SerializeIF::Endianness::BIG);
REQUIRE(result == returnvalue::OK); REQUIRE(result == returnvalue::OK);
REQUIRE(serSize == 7); REQUIRE(serSize == 7);
// Only version bits are set // Only version bits are set
@ -214,40 +214,49 @@ TEST_CASE("CFDP Header", "[cfdp]") {
REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT)); REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
} }
SECTION("Header Deserialization") { SECTION("Header Deserialization 0") {
REQUIRE(headerSerializer.serialize(&serTarget, &serSize, serBuf.size(), REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG) ==
SerializeIF::Endianness::BIG) == returnvalue::OK); returnvalue::OK);
REQUIRE(serBuf[1] == 0); REQUIRE(serBuf[1] == 0);
REQUIRE(serBuf[2] == 0); REQUIRE(serBuf[2] == 0);
// Entity and Transaction Sequence number are 1 byte large // Entity and Transaction Sequence number are 1 byte large
REQUIRE(serBuf[3] == 0b00010001); REQUIRE(serBuf[3] == 0b00010001);
REQUIRE(serSize == 7); REQUIRE(serSize == 7);
// Deser call not strictly necessary // Deser call not strictly necessary
auto headerDeser = HeaderReader(serBuf.data(), serBuf.size()); auto reader = PduHeaderReader(serBuf.data(), serBuf.size());
ReturnValue_t serResult = headerDeser.parseData(); ReturnValue_t serResult = reader.parseData();
REQUIRE(serResult == returnvalue::OK); REQUIRE(serResult == returnvalue::OK);
REQUIRE(headerDeser.getPduDataFieldLen() == 0); REQUIRE(reader.getPduDataFieldLen() == 0);
REQUIRE(headerDeser.getHeaderSize() == 7); REQUIRE(reader.getHeaderSize() == 7);
REQUIRE(headerDeser.getWholePduSize() == 7); REQUIRE(reader.getWholePduSize() == 7);
REQUIRE(headerDeser.getCrcFlag() == false); REQUIRE(reader.getCrcFlag() == false);
REQUIRE(headerDeser.getDirection() == cfdp::Direction::TOWARDS_RECEIVER); REQUIRE(reader.getDirection() == cfdp::Direction::TOWARDS_RECEIVER);
REQUIRE(headerDeser.getLargeFileFlag() == false); REQUIRE(reader.getLargeFileFlag() == false);
REQUIRE(headerDeser.getLenEntityIds() == 1); REQUIRE(reader.getLenEntityIds() == 1);
REQUIRE(headerDeser.getLenSeqNum() == 1); REQUIRE(reader.getLenSeqNum() == 1);
REQUIRE(headerDeser.getPduType() == cfdp::PduType::FILE_DIRECTIVE); REQUIRE(reader.getPduType() == cfdp::PduType::FILE_DIRECTIVE);
REQUIRE(headerDeser.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT); REQUIRE(reader.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
REQUIRE(headerDeser.getSegmentationControl() == false); REQUIRE(reader.getSegmentationControl() == false);
REQUIRE(headerDeser.getTransmissionMode() == cfdp::TransmissionModes::ACKNOWLEDGED); REQUIRE(reader.getTransmissionMode() == cfdp::TransmissionModes::ACKNOWLEDGED);
// No PDU data contained, so the PDU data field is empty
REQUIRE(reader.getPduDataField() == nullptr);
size_t deSerSize = reader.getWholePduSize();
serTarget = serBuf.data();
const auto** serTargetConst = const_cast<const uint8_t**>(&serTarget);
result = reader.parseData();
REQUIRE(result == returnvalue::OK);
}
SECTION("Header Deserialization 1") {
pduConf.crcFlag = true; pduConf.crcFlag = true;
pduConf.largeFile = true; pduConf.largeFile = true;
pduConf.direction = cfdp::Direction::TOWARDS_SENDER; pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
pduConf.mode = cfdp::TransmissionModes::UNACKNOWLEDGED; pduConf.mode = cfdp::TransmissionModes::UNACKNOWLEDGED;
headerSerializer.setSegmentationControl( creator.setSegmentationControl(cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION); creator.setPduType(cfdp::PduType::FILE_DATA);
headerSerializer.setPduType(cfdp::PduType::FILE_DATA); creator.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
headerSerializer.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
result = pduConf.seqNum.setValue(cfdp::WidthInBytes::TWO_BYTES, 0x0fff); result = pduConf.seqNum.setValue(cfdp::WidthInBytes::TWO_BYTES, 0x0fff);
REQUIRE(result == returnvalue::OK); REQUIRE(result == returnvalue::OK);
result = pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00); result = pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00);
@ -256,61 +265,63 @@ TEST_CASE("CFDP Header", "[cfdp]") {
REQUIRE(result == returnvalue::OK); REQUIRE(result == returnvalue::OK);
serTarget = serBuf.data(); serTarget = serBuf.data();
serSize = 0; serSize = 0;
result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(), result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
SerializeIF::Endianness::BIG); PduHeaderReader reader(serBuf.data(), serBuf.size());
headerDeser = HeaderReader(serBuf.data(), serBuf.size()); REQUIRE(reader.parseData() == returnvalue::OK);
result = headerDeser.parseData();
REQUIRE(result == returnvalue::OK);
// Everything except version bit flipped to one now // Everything except version bit flipped to one now
REQUIRE(serBuf[0] == 0x3f); REQUIRE(serBuf[0] == 0x3f);
REQUIRE(serBuf[3] == 0b11001010); REQUIRE(serBuf[3] == 0b11001010);
REQUIRE(headerDeser.getWholePduSize() == 14); REQUIRE(reader.getWholePduSize() == 14);
REQUIRE(headerDeser.getCrcFlag() == true); REQUIRE(reader.getCrcFlag() == true);
REQUIRE(headerDeser.getDirection() == cfdp::Direction::TOWARDS_SENDER); REQUIRE(reader.getDirection() == cfdp::Direction::TOWARDS_SENDER);
REQUIRE(headerDeser.getLargeFileFlag() == true); REQUIRE(reader.getLargeFileFlag() == true);
REQUIRE(headerDeser.getLenEntityIds() == 4); REQUIRE(reader.getLenEntityIds() == 4);
REQUIRE(headerDeser.getLenSeqNum() == 2); REQUIRE(reader.getLenSeqNum() == 2);
REQUIRE(headerDeser.getPduType() == cfdp::PduType::FILE_DATA); REQUIRE(reader.getPduType() == cfdp::PduType::FILE_DATA);
REQUIRE(headerDeser.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT); REQUIRE(reader.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
REQUIRE(headerDeser.getSegmentationControl() == true); REQUIRE(reader.getSegmentationControl() == true);
REQUIRE(headerDeser.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED); REQUIRE(reader.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED);
// Again, no data field set because this is a header only
REQUIRE(reader.getPduDataField() == nullptr);
cfdp::TransactionSeqNum seqNumLocal; cfdp::TransactionSeqNum seqNumLocal;
headerDeser.getTransactionSeqNum(seqNumLocal); reader.getTransactionSeqNum(seqNumLocal);
REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::TWO_BYTES); REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::TWO_BYTES);
REQUIRE(seqNumLocal.getValue() == 0x0fff); REQUIRE(seqNumLocal.getValue() == 0x0fff);
cfdp::EntityId sourceDestId; cfdp::EntityId sourceDestId;
headerDeser.getSourceId(sourceDestId); reader.getSourceId(sourceDestId);
REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES); REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES);
REQUIRE(sourceDestId.getValue() == 0xff00ff00); REQUIRE(sourceDestId.getValue() == 0xff00ff00);
headerDeser.getDestId(sourceDestId); reader.getDestId(sourceDestId);
REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES); REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES);
REQUIRE(sourceDestId.getValue() == 0x00ff00ff); REQUIRE(sourceDestId.getValue() == 0x00ff00ff);
CHECK(reader.setReadOnlyData(nullptr, -1) != returnvalue::OK);
REQUIRE(reader.getHeaderSize() == 14);
size_t deSerSize = headerDeser.getWholePduSize(); SECTION("Manipulate Source Dest ID") {
serTarget = serBuf.data(); serTarget = serBuf.data();
const auto** serTargetConst = const_cast<const uint8_t**>(&serTarget); serSize = 0;
result = headerDeser.parseData(); pduConf.sourceId.setValue(cfdp::WidthInBytes::ONE_BYTE, 22);
REQUIRE(result == returnvalue::OK); pduConf.destId.setValue(cfdp::WidthInBytes::ONE_BYTE, 48);
result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
reader.getSourceId(sourceDestId);
REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
REQUIRE(sourceDestId.getValue() == 22);
}
}
CHECK(headerDeser.setData(nullptr, -1) != returnvalue::OK); SECTION("Verify data field pointer") {
REQUIRE(headerDeser.getHeaderSize() == 14); FinishedInfo info(cfdp::ConditionCode::INACTIVITY_DETECTED,
headerDeser.setData(serBuf.data(), serBuf.size()); cfdp::FileDeliveryCode::DATA_INCOMPLETE,
cfdp::FileDeliveryStatus::DISCARDED_DELIBERATELY);
serTarget = serBuf.data(); FinishPduCreator finishCreator(pduConf, info);
serSize = 0; REQUIRE(finishCreator.serialize(serBuf.data(), serSize, serBuf.size()) == OK);
pduConf.sourceId.setValue(cfdp::WidthInBytes::ONE_BYTE, 22); // This PDU contains the directive code and some finishes PDU properties packed into one byte
pduConf.destId.setValue(cfdp::WidthInBytes::ONE_BYTE, 48); // in addition to the header
result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(), REQUIRE(finishCreator.getSerializedSize() == 9);
SerializeIF::Endianness::BIG); PduHeaderReader reader(serBuf.data(), serBuf.size());
REQUIRE(result == returnvalue::OK); REQUIRE(reader.parseData() == returnvalue::OK);
REQUIRE(headerDeser.getWholePduSize() == 8); REQUIRE(reader.getPduDataField() == serBuf.data() + 7);
headerDeser.setData(serBuf.data(), serBuf.size());
headerDeser.getSourceId(sourceDestId);
REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
REQUIRE(sourceDestId.getValue() == 22);
} }
} }

12
unittests/cfdp/pdu/testKeepAlivePdu.cpp
View File

@ -61,19 +61,19 @@ TEST_CASE("Keep Alive PDU", "[cfdp][pdu]") {
// Set another file size // Set another file size
progress.setFileSize(200, false); progress.setFileSize(200, false);
KeepAlivePduDeserializer deserializer(kaBuffer.data(), kaBuffer.size(), progress); KeepAlivePduDeserializer reader(kaBuffer.data(), kaBuffer.size(), progress);
result = deserializer.parseData(); result = reader.parseData();
REQUIRE(result == returnvalue::OK); REQUIRE(result == returnvalue::OK);
auto& progRef = deserializer.getProgress(); auto& progRef = reader.getProgress();
// Should have been overwritten // Should have been overwritten
REQUIRE(progRef.getSize() == 0x50); REQUIRE(progRef.getSize() == 0x50);
sz = deserializer.getWholePduSize(); sz = reader.getWholePduSize();
// invalid max size // invalid max size
for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) { for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
ReturnValue_t setResult = deserializer.setData(kaBuffer.data(), invalidMaxSz); ReturnValue_t setResult = reader.setReadOnlyData(kaBuffer.data(), invalidMaxSz);
if (setResult == returnvalue::OK) { if (setResult == returnvalue::OK) {
result = deserializer.parseData(); result = reader.parseData();
REQUIRE(result != returnvalue::OK); REQUIRE(result != returnvalue::OK);
} }
} }

2
unittests/cfdp/pdu/testPromptPdu.cpp
View File

@ -59,7 +59,7 @@ TEST_CASE("Prompt PDU", "[cfdp][pdu]") {
rawBuf[2] = 2; rawBuf[2] = 2;
for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) { for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
ReturnValue_t setResult = deserializer.setData(rawBuf.data(), invalidMaxSz); ReturnValue_t setResult = deserializer.setReadOnlyData(rawBuf.data(), invalidMaxSz);
if (setResult == returnvalue::OK) { if (setResult == returnvalue::OK) {
result = deserializer.parseData(); result = deserializer.parseData();
REQUIRE(result != returnvalue::OK); REQUIRE(result != returnvalue::OK);