Merge branch 'development' into mohr_introspection

CHANGELOG.md

@@ -10,6 +10,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Fixes
 
+- Important bugfix in CFDP PDU header format: The entity length field and the transaction sequence
+  number fields stored the actual length of the field instead of the length minus 1 like specified
+  in the CFDP standard.
 - PUS Health Service: Size check for set health command.
   Perform operation completion for announce health command.
   https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/746

automation/Jenkinsfile

@@ -97,7 +97,7 @@ pipeline {
                         sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/development'
                     }
                 }
-                dir(BUILDDIR) {
+                dir(BUILDDIR_LINUX) {
                     sshagent(credentials: ['documentation-buildfix']) {
                         sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/development'
                     }
@@ -116,7 +116,7 @@ pipeline {
                         sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/master'
                     }
                 }
-                dir(BUILDDIR) {
+                dir(BUILDDIR_LINUX) {
                     sshagent(credentials: ['documentation-buildfix']) {
                         sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/master'
                     }

src/fsfw/cfdp/VarLenFields.h

@@ -51,8 +51,9 @@ class VarLenField : public SerializeIF {
     return os;
   }
 #endif
-
  private:
+  using SerializeIF::deSerialize;  // we overloaded above, so this is needed to uncofuse the
+                                   // compiler
   ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                             Endianness streamEndianness) override;
 

src/fsfw/cfdp/pdu/HeaderCreator.cpp

@@ -24,8 +24,8 @@ ReturnValue_t HeaderCreator::serialize(uint8_t **buffer, size_t *size, size_t ma
   *buffer += 1;
   **buffer = pduDataFieldLen & 0x00ff;
   *buffer += 1;
-  **buffer = segmentationCtrl << 7 | pduConf.sourceId.getWidth() << 4 | segmentMetadataFlag << 3 |
-             pduConf.seqNum.getWidth();
+  **buffer = segmentationCtrl << 7 | ((pduConf.sourceId.getWidth() - 1) << 4) |
+             segmentMetadataFlag << 3 | (pduConf.seqNum.getWidth() - 1);
   *buffer += 1;
   *size += 4;
   ReturnValue_t result = pduConf.sourceId.serialize(buffer, size, maxSize, streamEndianness);

src/fsfw/cfdp/pdu/HeaderReader.cpp

@@ -78,11 +78,11 @@ cfdp::SegmentationControl PduHeaderReader::getSegmentationControl() 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) & 0b111) + 1);
 }
 
 cfdp::WidthInBytes PduHeaderReader::getLenSeqNum() const {
-  return static_cast<cfdp::WidthInBytes>(pointers.fixedHeader->fourthByte & 0x07);
+  return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte & 0b111) + 1);
 }
 
 cfdp::SegmentMetadataFlag PduHeaderReader::getSegmentMetadataFlag() const {

src/fsfw/cfdp/tlv/EntityIdTlv.h

@@ -23,6 +23,8 @@ class EntityIdTlv : public TlvIF {
    */
   ReturnValue_t deSerialize(cfdp::Tlv& tlv, Endianness endianness);
 
+  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
+                                   // the compiler
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                             Endianness streamEndianness) override;
 

src/fsfw/cfdp/tlv/FilestoreResponseTlv.h

@@ -29,6 +29,8 @@ class FilestoreResponseTlv : public cfdp::FilestoreTlvBase {
    */
   ReturnValue_t deSerialize(const cfdp::Tlv& tlv, Endianness endianness);
 
+  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
+                                   // the compiler
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                             Endianness streamEndianness) override;
 

src/fsfw/container/FixedMap.h

@@ -155,8 +155,8 @@ class FixedMap : public SerializeIF {
 
   uint32_t maxSize() const { return theMap.maxSize(); }
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const {
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override {
     ReturnValue_t result =
         SerializeAdapter::serialize(&this->_size, buffer, size, maxSize, streamEndianness);
     uint32_t i = 0;
@@ -170,7 +170,7 @@ class FixedMap : public SerializeIF {
     return result;
   }
 
-  virtual size_t getSerializedSize() const {
+  size_t getSerializedSize() const override {
     uint32_t printSize = sizeof(_size);
     uint32_t i = 0;
 
@@ -182,8 +182,8 @@ class FixedMap : public SerializeIF {
     return printSize;
   }
 
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) {
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
     ReturnValue_t result =
         SerializeAdapter::deSerialize(&this->_size, buffer, size, streamEndianness);
     if (this->_size > theMap.maxSize()) {

src/fsfw/datapool/PoolDataSetBase.h

@@ -64,8 +64,8 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
    * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
    *      commit() in between
    */
-  virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                             uint32_t lockTimeout = 20) override;
+  ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                     uint32_t lockTimeout = 20) override;
   /**
    * @brief	The commit call initializes writing back the registered variables.
    * @details
@@ -84,15 +84,15 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
    * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
    * 			  contains non write-only variables
    */
-  virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                               uint32_t lockTimeout = 20) override;
+  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                       uint32_t lockTimeout = 20) override;
 
   /**
    * Register the passed pool variable instance into the data set.
    * @param variable
    * @return
    */
-  virtual ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+  ReturnValue_t registerVariable(PoolVariableIF* variable) override;
 
   /**
    * Provides the means to lock the underlying data structure to ensure

src/fsfw/datapoollocal/LocalPoolVariable.h

@@ -87,9 +87,9 @@ class LocalPoolVariable : public LocalPoolObjectBase {
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           SerializeIF::Endianness streamEndianness) const override;
-  virtual size_t getSerializedSize() const override;
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    SerializeIF::Endianness streamEndianness) override;
+  size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            SerializeIF::Endianness streamEndianness) override;
 
   /**
    * @brief	This is a call to read the array's values

src/fsfw/datapoollocal/LocalPoolVector.h

@@ -98,11 +98,11 @@ class LocalPoolVector : public LocalPoolObjectBase {
   T& operator[](size_t i);
   const T& operator[](size_t i) const;
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
-                                  SerializeIF::Endianness streamEndiannes) const override;
-  virtual size_t getSerializedSize() const override;
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    SerializeIF::Endianness streamEndianness) override;
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
+                          SerializeIF::Endianness streamEndiannes) const override;
+  size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            SerializeIF::Endianness streamEndianness) override;
 
   /**
    * @brief	This is a call to read the array's values

src/fsfw/events/EventManager.h

@@ -21,7 +21,6 @@ extern const char* translateEvents(Event event);
 
 class EventManager : public EventManagerIF, public ExecutableObjectIF, public SystemObject {
  public:
-
   EventManager(object_id_t setObjectId, uint32_t eventQueueDepth);
   virtual ~EventManager();
 

src/fsfw/globalfunctions/Type.h

@@ -44,13 +44,13 @@ class Type : public SerializeIF {
 
   static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
 
-  virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                  Endianness streamEndianness) const override;
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override;
 
-  virtual size_t getSerializedSize() const override;
+  size_t getSerializedSize() const override;
 
-  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                                    Endianness streamEndianness) override;
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override;
 
  private:
   ActualType_t actualType;

src/fsfw/housekeeping/HousekeepingSnapshot.h

@@ -54,8 +54,8 @@ class HousekeepingSnapshot : public SerializeIF {
   HousekeepingSnapshot(uint8_t* timeStamp, size_t timeStampSize, LocalPoolObjectBase* dataSetPtr)
       : timeStamp(timeStamp), timeStampSize(timeStampSize), updateData(dataSetPtr){};
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const {
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const {
     if (timeStamp != nullptr) {
       /* Endianness will always be MACHINE, so we can simply use memcpy
       here. */
@@ -70,15 +70,15 @@ class HousekeepingSnapshot : public SerializeIF {
     return updateData->serialize(buffer, size, maxSize, streamEndianness);
   }
 
-  virtual size_t getSerializedSize() const {
+  size_t getSerializedSize() const {
     if (updateData == nullptr) {
       return 0;
     }
     return timeStampSize + updateData->getSerializedSize();
   }
 
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    SerializeIF::Endianness streamEndianness) override {
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            SerializeIF::Endianness streamEndianness) override {
     if (*size < timeStampSize) {
       return SerializeIF::STREAM_TOO_SHORT;
     }

src/fsfw/monitoring/AbsLimitMonitor.h

@@ -32,9 +32,9 @@ class AbsLimitMonitor : public MonitorBase<T> {
     return returnvalue::OK;  // We're not out of range.
   }
 
-  virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
-                                     ParameterWrapper *parameterWrapper,
-                                     const ParameterWrapper *newValues, uint16_t startAtIndex) {
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t parameterId,
+                             ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
+                             uint16_t startAtIndex) override {
     ReturnValue_t result = this->MonitorBase<T>::getParameter(
         domainId, parameterId, parameterWrapper, newValues, startAtIndex);
     // We'll reuse the DOMAIN_ID of MonitorReporter,

src/fsfw/monitoring/MonitoringMessage.h

@@ -13,6 +13,7 @@ class MonitoringMessage : public CommandMessage {
   static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
   virtual ~MonitoringMessage();
   static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
+  using CommandMessage::clear;
   static void clear(CommandMessage* message);
   static store_address_t getStoreId(const CommandMessage* message);
   static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);

src/fsfw/osal/host/FixedTimeslotTask.h

@@ -5,6 +5,7 @@
 #include <condition_variable>
 #include <thread>
 #include <vector>
+#include <string>
 
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/tasks/FixedSlotSequence.h"

src/fsfw/osal/host/PeriodicTask.h

@@ -5,6 +5,7 @@
 #include <condition_variable>
 #include <thread>
 #include <vector>
+#include <string>
 
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/tasks/PeriodicTaskBase.h"

src/fsfw/osal/host/taskHelpers.h

@@ -4,6 +4,7 @@
 #include <fsfw/returnvalues/returnvalue.h>
 
 #include <thread>
+#include <string>
 
 namespace tasks {
 

src/fsfw/osal/rtems/CpuUsage.h

@@ -19,13 +19,13 @@ class CpuUsage : public SerializeIF {
     float timeRunning;
     float percentUsage;
 
-    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                    Endianness streamEndianness) const override;
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                            Endianness streamEndianness) const override;
 
-    virtual size_t getSerializedSize() const override;
+    size_t getSerializedSize() const override;
 
-    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                      Endianness streamEndianness) override;
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                              Endianness streamEndianness) override;
   };
 
   CpuUsage();

src/fsfw/parameters/ParameterWrapper.h

@@ -40,13 +40,15 @@ class ParameterWrapper : public SerializeIF {
   ParameterWrapper(Type type, uint8_t rows, uint8_t columns, const void *data);
   virtual ~ParameterWrapper();
 
-  virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                  Endianness streamEndianness) const override;
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override;
 
-  virtual size_t getSerializedSize() const override;
+  size_t getSerializedSize() const override;
 
-  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                                    Endianness streamEndianness) override;
+  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
+                                   // the compiler
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override;
 
   virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                                     Endianness streamEndianness, uint16_t startWritingAtIndex = 0);

src/fsfw/pus/servicepackets/Service5Packets.h

@@ -24,8 +24,8 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
         parameter1(parameter1_),
         parameter2(parameter2_) {}
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  SerializeIF::Endianness streamEndianness) const override {
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          SerializeIF::Endianness streamEndianness) const override {
     ReturnValue_t result =
         SerializeAdapter::serialize(&reportId, buffer, size, maxSize, streamEndianness);
     if (result != returnvalue::OK) {
@@ -46,7 +46,7 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
     return result;
   }
 
-  virtual size_t getSerializedSize() const override {
+  size_t getSerializedSize() const override {
     uint32_t size = 0;
     size += SerializeAdapter::getSerializedSize(&reportId);
     size += SerializeAdapter::getSerializedSize(&objectId);
@@ -55,8 +55,8 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
     return size;
   }
 
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    SerializeIF::Endianness streamEndianness) override {
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            SerializeIF::Endianness streamEndianness) override {
     return returnvalue::FAILED;
   }
 

src/fsfw/serialize/SerialArrayListAdapter.h

@@ -16,8 +16,10 @@ class SerialArrayListAdapter : public SerializeIF {
  public:
   SerialArrayListAdapter(ArrayList<T, count_t>* adaptee) : adaptee(adaptee) {}
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const {
+  using SerializeIF::serialize;  // we overload this function as well, so this is needed to uncofuse
+                                 // the compiler
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override {
     return serialize(adaptee, buffer, size, maxSize, streamEndianness);
   }
 
@@ -34,7 +36,7 @@ class SerialArrayListAdapter : public SerializeIF {
     return result;
   }
 
-  virtual size_t getSerializedSize() const { return getSerializedSize(adaptee); }
+  size_t getSerializedSize() const override { return getSerializedSize(adaptee); }
 
   static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
     uint32_t printSize = sizeof(count_t);
@@ -47,8 +49,10 @@ class SerialArrayListAdapter : public SerializeIF {
     return printSize;
   }
 
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) {
+  using SerializeIF::deSerialize;  // we overload this function as well, so this is needed to
+                                   // uncofuse the compiler
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
     return deSerialize(adaptee, buffer, size, streamEndianness);
   }
 

src/fsfw/serialize/SerialLinkedListAdapter.h

@@ -45,8 +45,10 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
   SerialLinkedListAdapter(bool printCount = false)
       : SinglyLinkedList<T>(), printCount(printCount) {}
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const override {
+  using SerializeIF::serialize;  // we overloaded this function, so this is needed to unconfuse the
+                                 // compiler
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override {
     if (printCount) {
       count_t mySize = SinglyLinkedList<T>::getSize();
       ReturnValue_t result =
@@ -68,7 +70,7 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
     return result;
   }
 
-  virtual size_t getSerializedSize() const override {
+  size_t getSerializedSize() const override {
     if (printCount) {
       return SerialLinkedListAdapter<T>::getSerializedSize() + sizeof(count_t);
     } else {
@@ -76,6 +78,8 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
     }
   }
 
+  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
+                                   // the compiler
   static size_t getSerializedSize(const LinkedElement<T>* element) {
     size_t size = 0;
     while (element != nullptr) {
@@ -85,8 +89,8 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
     return size;
   }
 
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) override {
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
     return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
   }
 

src/fsfw/serialize/SerializeElement.h

@@ -32,8 +32,8 @@ class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
 
   size_t getSerializedSize() const override { return SerializeAdapter::getSerializedSize(&entry); }
 
-  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                                    Endianness streamEndianness) override {
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override {
     return SerializeAdapter::deSerialize(&entry, buffer, size, streamEndianness);
   }
 

src/fsfw/subsystem/modes/ModeDefinitions.h

@@ -15,8 +15,8 @@ class ModeListEntry : public SerializeIF, public LinkedElement<ModeListEntry> {
   uint8_t value3 = 0;
   uint8_t value4 = 0;
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const {
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override {
     ReturnValue_t result;
 
     result = SerializeAdapter::serialize(&value1, buffer, size, maxSize, streamEndianness);
@@ -40,12 +40,12 @@ class ModeListEntry : public SerializeIF, public LinkedElement<ModeListEntry> {
     return result;
   }
 
-  virtual size_t getSerializedSize() const {
+  size_t getSerializedSize() const override {
     return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
   }
 
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) {
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
     ReturnValue_t result;
 
     result = SerializeAdapter::deSerialize(&value1, buffer, size, streamEndianness);

unittests/cfdp/pdu/testCfdpHeader.cpp

@@ -97,7 +97,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
       REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(),
                                 SerializeIF::Endianness::BIG) == returnvalue::OK);
       CHECK(serBuf[0] == 0x3f);
-      CHECK(serBuf[3] == 0x99);
+      CHECK(serBuf[3] == 0x88);
       REQUIRE(creator.getCrcFlag() == true);
       REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_SENDER);
       REQUIRE(creator.getLargeFileFlag() == true);
@@ -127,7 +127,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
       REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionMode::UNACKNOWLEDGED);
       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)
-      REQUIRE(serBuf[3] == 0b11001010);
+      REQUIRE(serBuf[3] == 0b10111001);
       uint32_t entityId = 0;
       size_t deSerSize = 0;
       SerializeAdapter::deSerialize(&entityId, serBuf.data() + 4, &deSerSize,
@@ -175,7 +175,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
     REQUIRE(serBuf[1] == 0);
     REQUIRE(serBuf[2] == 0);
     // Entity and Transaction Sequence number are 1 byte large
-    REQUIRE(serBuf[3] == 0b00010001);
+    REQUIRE(serBuf[3] == 0b00000000);
     // Source ID
     REQUIRE(serBuf[4] == 0);
     // Transaction Seq Number
@@ -220,7 +220,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
     REQUIRE(serBuf[1] == 0);
     REQUIRE(serBuf[2] == 0);
     // Entity and Transaction Sequence number are 1 byte large
-    REQUIRE(serBuf[3] == 0b00010001);
+    REQUIRE(serBuf[3] == 0b00000000);
     REQUIRE(serSize == 7);
     // Deser call not strictly necessary
     auto reader = PduHeaderReader(serBuf.data(), serBuf.size());
@@ -270,7 +270,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
     REQUIRE(reader.parseData() == returnvalue::OK);
     // Everything except version bit flipped to one now
     REQUIRE(serBuf[0] == 0x3f);
-    REQUIRE(serBuf[3] == 0b11001010);
+    REQUIRE(serBuf[3] == 0b10111001);
     REQUIRE(reader.getWholePduSize() == 14);
 
     REQUIRE(reader.getCrcFlag() == true);

unittests/cfdp/pdu/testFileData.cpp

@@ -68,7 +68,7 @@ TEST_CASE("File Data PDU", "[cfdp][pdu]") {
     // Bits 1 to 3 length of enitity IDs is 2
     // Bit 4: Segment metadata flag is set
     // Bit 5 to seven: length of transaction seq num is 2
-    REQUIRE(fileDataBuffer[3] == 0b10101010);
+    REQUIRE(fileDataBuffer[3] == 0b10011001);
     REQUIRE((fileDataBuffer[10] >> 6) &
             0b11 == cfdp::RecordContinuationState::CONTAINS_START_AND_END);
     // Segment metadata length

unittests/cfdp/pdu/testFileDirective.cpp

@@ -30,7 +30,7 @@ TEST_CASE("CFDP File Directive", "[cfdp][pdu]") {
     REQUIRE(serBuf[1] == 0);
     REQUIRE(serBuf[2] == 5);
     // Entity and Transaction Sequence number are 1 byte large
-    REQUIRE(serBuf[3] == 0b00010001);
+    REQUIRE(serBuf[3] == 0b00000000);
     // Source ID
     REQUIRE(serBuf[4] == 0);
     // Transaction Seq Number
@@ -82,4 +82,4 @@ TEST_CASE("CFDP File Directive", "[cfdp][pdu]") {
     // Invalid file directive
     REQUIRE(fdDeser.parseData() == cfdp::INVALID_DIRECTIVE_FIELD);
   }
-}
+}

unittests/cfdp/testCfdp.cpp

@@ -33,8 +33,8 @@ TEST_CASE("CFDP Base", "[cfdp]") {
     // PDU data field length is 5 (4 + Directive code octet)
     REQUIRE(serBuf[1] == 0);
     REQUIRE(serBuf[2] == 5);
-    // Entity and Transaction Sequence number are 1 byte large
-    REQUIRE(serBuf[3] == 0b00010001);
+    // Entity and Transaction Sequence number are 1 byte large, value minus one is stored
+    REQUIRE(serBuf[3] == 0b00000000);
     // Source ID
     REQUIRE(serBuf[4] == 0);
     // Transaction Seq Number