set deser test complete

new bitutility file

datapoollocal/LocalPoolDataSetBase.cpp

@@ -3,6 +3,7 @@
 #include "internal/HasLocalDpIFUserAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
+#include "../globalfunctions/bitutility.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
 #include "../serialize/SerializeAdapter.h"
@@ -102,7 +103,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
             /* Set bit at correct position */
-            this->bitSetter(validityMask + validBufferIndex, validBufferIndexBit);
+            bitutil::bitSet(validityMask + validBufferIndex, validBufferIndexBit);
         }
         if(validBufferIndexBit == 7) {
             validBufferIndex ++;
@@ -148,7 +149,7 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     uint8_t validBufferIndexBit = 0;
     for (uint16_t count = 0; count < fillCount; count++) {
         // set validity buffer here.
-        bool nextVarValid = this->bitGetter(*buffer +
+        bool nextVarValid = bitutil::bitGet(*buffer +
                 validBufferIndex, validBufferIndexBit);
         registeredVariables[count]->setValid(nextVarValid);
 
@@ -301,29 +302,3 @@ object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
     return objects::NO_OBJECT;
 }
 
-void LocalPoolDataSetBase::bitSetter(uint8_t* byte, uint8_t position) {
-    if(position > 7) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LocalPoolDataSetBase::bitSetter: Invalid position!"
-                << std::endl;
-#else
-        sif::printWarning("LocalPoolDataSetBase::bitSetter: "
-                "Invalid position!\n\r");
-#endif
-        return;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    *byte |= 1 << shiftNumber;
-}
-
-bool LocalPoolDataSetBase::bitGetter(const uint8_t* byte, uint8_t position) {
-    if(position > 7) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "Pool Raw Access: Bit setting invalid position"
-                << std::endl;
-#endif
-        return false;
-    }
-    uint8_t shiftNumber = position + (7 - 2 * position);
-    return *byte & (1 << shiftNumber);
-}

datapoollocal/LocalPoolDataSetBase.h

@@ -160,13 +160,6 @@ public:
 
     object_id_t getCreatorObjectId();
 
-    /* Static helper functions for manipulating validity buffers */
-    /**
-     * Set n-th bit of a byte, with n being the position from 0
-     * (most significant bit) to 7 (least significant bit)
-     */
-    static void bitSetter(uint8_t* byte, uint8_t position);
-    static bool bitGetter(const uint8_t* byte, uint8_t position);
 protected:
     sid_t sid;
     //! This mutex is used if the data is created by one object only.

globalfunctions/CMakeLists.txt

@@ -7,6 +7,7 @@ target_sources(${LIB_FSFW_NAME}
 		PeriodicOperationDivider.cpp
 		timevalOperations.cpp
 		Type.cpp
+		bitutility.cpp
 )
 
-add_subdirectory(math)
+add_subdirectory(math)

globalfunctions/bitutility.cpp

@@ -0,0 +1,33 @@
+#include "bitutility.h"
+
+void bitutil::bitSet(uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte |= 1 << shiftNumber;
+}
+
+void bitutil::bitToggle(uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte ^= 1 << shiftNumber;
+}
+
+void bitutil::bitClear(uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    *byte &= ~(1 << shiftNumber);
+}
+
+bool bitutil::bitGet(const uint8_t *byte, uint8_t position) {
+    if(position > 7) {
+        return false;
+    }
+    uint8_t shiftNumber = position + (7 - 2 * position);
+    return *byte & (1 << shiftNumber);
+}

globalfunctions/bitutility.h

@@ -0,0 +1,18 @@
+#ifndef FSFW_GLOBALFUNCTIONS_BITUTIL_H_
+#define FSFW_GLOBALFUNCTIONS_BITUTIL_H_
+
+#include <cstdint>
+
+namespace bitutil {
+
+/* Helper functions for manipulating the individual bits of a byte.
+Position refers to n-th bit of a byte, going from 0 (most significant bit) to
+7 (least significant bit) */
+void bitSet(uint8_t* byte, uint8_t position);
+void bitToggle(uint8_t* byte, uint8_t position);
+void bitClear(uint8_t* byte, uint8_t position);
+bool bitGet(const uint8_t* byte, uint8_t position);
+
+}
+
+#endif /* FSFW_GLOBALFUNCTIONS_BITUTIL_H_ */

unittest/tests/datapoollocal/DataSetTest.cpp

@@ -6,6 +6,8 @@
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/datapool/PoolReadHelper.h>
+#include <fsfw/globalfunctions/bitutility.h>
+
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
@@ -160,12 +162,31 @@ TEST_CASE("LocalDataSet" , "[LocDataSetTest]") {
             CHECK(rawUint16Vec[2] == 1);
             /* We can do it like this because the buffer only has one byte for
             less than 8 variables */
-            uint8_t validityByte = buffer[sizeof(buffer) - 1];
+            uint8_t* validityByte = buffer + sizeof(buffer) - 1;
-            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 0) == true);
+            CHECK(bitutil::bitGet(validityByte, 0) == true);
-            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 1) == false);
+            CHECK(bitutil::bitGet(validityByte, 1) == false);
-            CHECK(LocalPoolDataSetBase::bitGetter(&validityByte, 2) == true);
+            CHECK(bitutil::bitGet(validityByte, 2) == true);
 
             /* Now we manipulate the validity buffer for the deserialization */
+            bitutil::bitClear(validityByte, 0);
+            bitutil::bitSet(validityByte, 1);
+            bitutil::bitClear(validityByte, 2);
+            /* Zero out everything except validity buffer */
+            std::memset(buffer, 0, sizeof(buffer) - 1);
+            sizeToDeserialize = maxSize;
+            constBuffPtr = buffer;
+            CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
+                    SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+            /* Check whether deserialization was successfull */
+            CHECK(localSet.localPoolVarUint8.value == 0);
+            CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+            CHECK(localSet.localPoolVarUint8.value == 0);
+            CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+            CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+            CHECK(not localSet.localPoolVarUint8.isValid());
+            CHECK(localSet.localPoolVarFloat.isValid());
+            CHECK(not localSet.localPoolUint16Vec.isValid());
 
         }