Merge remote-tracking branch 'origin/development' into mueller/expand-retval-if

unittests/serialize/CMakeLists.txt

@@ -1,5 +1,6 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
-	TestSerialBufferAdapter.cpp
-	TestSerialization.cpp
-	TestSerialLinkedPacket.cpp
+	testSerialBufferAdapter.cpp
+  testSerializeAdapter.cpp
+	testSerialLinkedPacket.cpp
+	testSerializeIF.cpp
 )

unittests/serialize/SerialLinkedListAdapterPacket.h

@@ -26,13 +26,13 @@ class TestPacket : public SerialLinkedListAdapter<SerializeIF> {
     setLinks();
   }
 
-  uint32_t getHeader() const { return header.entry; }
+  [[nodiscard]] uint32_t getHeader() const { return header.entry; }
 
-  const uint8_t* getBuffer() { return buffer.entry.getConstBuffer(); }
+  [[nodiscard]] const uint8_t* getBuffer() const { return buffer.entry.getConstBuffer(); }
 
   size_t getBufferLength() { return buffer.getSerializedSize(); }
 
-  uint16_t getTail() const { return tail.entry; }
+  [[nodiscard]] uint16_t getTail() const { return tail.entry; }
 
  private:
   void setLinks() {
@@ -47,4 +47,4 @@ class TestPacket : public SerialLinkedListAdapter<SerializeIF> {
   SerializeElement<uint32_t> tail = 0;
 };
 
-#endif /* UNITTEST_TESTFW_NEWTESTS_TESTTEMPLATE_H_ */
+#endif /* UNITTEST_HOSTED_TESTSERIALLINKEDPACKET_H_ */

unittests/serialize/testSerialBufferAdapter.cpp

@@ -92,7 +92,7 @@ TEST_CASE("Serial Buffer Adapter", "[single-file]") {
     testArray[3] = 1;
     testArray[4] = 1;
     testArray[5] = 0;
-    std::array<uint8_t, 4> test_recv_array;
+    std::array<uint8_t, 4> test_recv_array{};
     arrayPtr = testArray.data();
     // copy testArray[1] to testArray[4] into receive buffer, skip
     // size field (testArray[0]) for deSerialization.
@@ -116,7 +116,7 @@ TEST_CASE("Serial Buffer Adapter", "[single-file]") {
     testArray[3] = 1;
     testArray[4] = 1;
     testArray[5] = 0;
-    std::array<uint8_t, 4> test_recv_array;
+    std::array<uint8_t, 4> test_recv_array{};
     arrayPtr = testArray.data() + 2;
     // copy testArray[1] to testArray[4] into receive buffer, skip
     // size field (testArray[0])

unittests/serialize/testSerialLinkedPacket.cpp

@@ -1,11 +1,10 @@
-#include "TestSerialLinkedPacket.h"
-
 #include <fsfw/globalfunctions/arrayprinter.h>
 
 #include <array>
 #include <catch2/catch_test_macros.hpp>
 
 #include "CatchDefinitions.h"
+#include "SerialLinkedListAdapterPacket.h"
 
 TEST_CASE("Serial Linked Packet", "[SerLinkPacket]") {
   // perform set-up here

unittests/serialize/testSerializeIF.cpp

@@ -0,0 +1,144 @@
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "mocks/SimpleSerializable.h"
+
+using namespace std;
+
+TEST_CASE("Serialize IF Serialize", "[serialize-if-ser]") {
+  auto simpleSer = SimpleSerializable();
+  array<uint8_t, 16> buf{};
+  uint8_t* ptr = buf.data();
+  size_t len = 0;
+
+  SECTION("Little Endian Normal") {
+    REQUIRE(simpleSer.serialize(&ptr, &len, buf.size(), SerializeIF::Endianness::LITTLE) ==
+            HasReturnvaluesIF::RETURN_OK);
+    CHECK(buf[0] == 1);
+    CHECK(buf[1] == 3);
+    CHECK(buf[2] == 2);
+    // Verify pointer arithmetic and size increment
+    CHECK(ptr == buf.data() + 3);
+    CHECK(len == 3);
+  }
+
+  SECTION("Little Endian Simple") {
+    size_t serLen = 0xff;
+    REQUIRE(simpleSer.SerializeIF::serialize(buf.data(), serLen, buf.size(),
+                                             SerializeIF::Endianness::LITTLE) ==
+            HasReturnvaluesIF::RETURN_OK);
+    CHECK(buf[0] == 1);
+    CHECK(buf[1] == 3);
+    CHECK(buf[2] == 2);
+    CHECK(serLen == 3);
+  }
+
+  SECTION("Big Endian Normal") {
+    SECTION("Explicit") {
+      REQUIRE(simpleSer.serialize(&ptr, &len, buf.size(), SerializeIF::Endianness::BIG) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 0") {
+      REQUIRE(simpleSer.serialize(&ptr, &len, buf.size(), SerializeIF::Endianness::NETWORK) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 1") {
+      REQUIRE(simpleSer.serializeBe(&ptr, &len, buf.size()) == HasReturnvaluesIF::RETURN_OK);
+    }
+
+    CHECK(buf[0] == 1);
+    CHECK(buf[1] == 2);
+    CHECK(buf[2] == 3);
+    // Verify pointer arithmetic and size increment
+    CHECK(ptr == buf.data() + 3);
+    CHECK(len == 3);
+  }
+
+  SECTION("Big Endian Simple") {
+    size_t serLen = 0xff;
+    SECTION("Explicit") {
+      REQUIRE(simpleSer.SerializeIF::serialize(buf.data(), serLen, buf.size(),
+                                               SerializeIF::Endianness::BIG) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 0") {
+      REQUIRE(simpleSer.SerializeIF::serialize(buf.data(), serLen, buf.size(),
+                                               SerializeIF::Endianness::NETWORK) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 1") {
+      REQUIRE(simpleSer.SerializeIF::serializeBe(buf.data(), serLen, buf.size()) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    CHECK(buf[0] == 1);
+    CHECK(buf[1] == 2);
+    CHECK(buf[2] == 3);
+    CHECK(serLen == 3);
+  }
+}
+
+TEST_CASE("SerializeIF Deserialize", "[serialize-if-de]") {
+  auto simpleSer = SimpleSerializable();
+  array<uint8_t, 3> buf = {5, 0, 1};
+  const uint8_t* ptr = buf.data();
+  size_t len = buf.size();
+
+  SECTION("Little Endian Normal") {
+    REQUIRE(simpleSer.deSerialize(&ptr, &len, SerializeIF::Endianness::LITTLE) ==
+            HasReturnvaluesIF::RETURN_OK);
+    CHECK(simpleSer.getU8() == 5);
+    CHECK(simpleSer.getU16() == 0x0100);
+    CHECK(ptr == buf.data() + 3);
+    CHECK(len == 0);
+  }
+
+  SECTION("Little Endian Simple") {
+    size_t deserLen = 0xff;
+    REQUIRE(
+        simpleSer.SerializeIF::deSerialize(ptr, deserLen, len, SerializeIF::Endianness::LITTLE) ==
+        HasReturnvaluesIF::RETURN_OK);
+    CHECK(simpleSer.getU8() == 5);
+    CHECK(simpleSer.getU16() == 0x0100);
+    CHECK(deserLen == 3);
+  }
+
+  SECTION("Big Endian Normal") {
+    SECTION("Explicit") {
+      REQUIRE(simpleSer.deSerialize(&ptr, &len, SerializeIF::Endianness::BIG) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 0") {
+      REQUIRE(simpleSer.deSerialize(&ptr, &len, SerializeIF::Endianness::NETWORK) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 1") {
+      REQUIRE(simpleSer.SerializeIF::deSerializeBe(&ptr, &len) == HasReturnvaluesIF::RETURN_OK);
+    }
+    CHECK(simpleSer.getU8() == 5);
+    CHECK(simpleSer.getU16() == 1);
+    CHECK(ptr == buf.data() + 3);
+    CHECK(len == 0);
+  }
+
+  SECTION("Big Endian Simple") {
+    size_t deserLen = 0xff;
+    SECTION("Explicit") {
+      REQUIRE(simpleSer.SerializeIF::deSerialize(buf.data(), deserLen, buf.size(),
+                                                 SerializeIF::Endianness::BIG) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 0") {
+      REQUIRE(simpleSer.SerializeIF::deSerialize(buf.data(), deserLen, buf.size(),
+                                                 SerializeIF::Endianness::NETWORK) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    SECTION("Network 1") {
+      REQUIRE(simpleSer.SerializeIF::deSerializeBe(buf.data(), deserLen, buf.size()) ==
+              HasReturnvaluesIF::RETURN_OK);
+    }
+    CHECK(simpleSer.getU8() == 5);
+    CHECK(simpleSer.getU16() == 1);
+    CHECK(deserLen == 3);
+  }
+}