Revise DpContainer and unit tests

Don't fail an assertion on bad serial input

Fw/Dp/DpContainer.cpp

@@ -35,39 +35,55 @@ DpContainer::DpContainer()
 // Public member functions
 // ----------------------------------------------------------------------
 
-void DpContainer::deserializeHeader() {
+Fw::SerializeStatus DpContainer::deserializeHeader() {
     FW_ASSERT(this->m_buffer.isValid());
     Fw::SerializeBufferBase& serializeRepr = this->m_buffer.getSerializeRepr();
     // Reset deserialization
     serializeRepr.setBuffLen(this->m_buffer.getSize());
-    Fw::SerializeStatus status = serializeRepr.moveDeserToOffset(Header::ID_OFFSET);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
+    Fw::SerializeStatus status = serializeRepr.moveDeserToOffset(Header::PACKET_DESCRIPTOR_OFFSET);
+    // Deserialize the packet type
+    if (status == Fw::FW_SERIALIZE_OK) {
+        FwPacketDescriptorType packetDescriptor;
+        status = serializeRepr.deserialize(packetDescriptor);
+        if (packetDescriptor != Fw::ComPacket::FW_PACKET_DP) {
+            status = Fw::FW_SERIALIZE_FORMAT_ERROR;
+        }
+    }
     // Deserialize the container id
-    status = serializeRepr.deserialize(this->m_id);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
+    if (status == Fw::FW_SERIALIZE_OK) {
+        status = serializeRepr.deserialize(this->m_id);
+    }
     // Deserialize the priority
-    status = serializeRepr.deserialize(this->m_priority);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
+    if (status == Fw::FW_SERIALIZE_OK) {
+        status = serializeRepr.deserialize(this->m_priority);
+    }
     // Deserialize the time tag
-    status = serializeRepr.deserialize(this->m_timeTag);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
+    if (status == Fw::FW_SERIALIZE_OK) {
+        status = serializeRepr.deserialize(this->m_timeTag);
+    }
     // Deserialize the processing types
-    status = serializeRepr.deserialize(this->m_procTypes);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
+    if (status == Fw::FW_SERIALIZE_OK) {
+        status = serializeRepr.deserialize(this->m_procTypes);
+    }
     // Deserialize the user data
-    const bool omitLength = true;
-    const FwSizeType requestedSize = sizeof this->m_userData;
-    FwSizeType receivedSize = requestedSize;
-    status = serializeRepr.deserialize(this->m_userData, receivedSize, omitLength);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
-    FW_ASSERT(receivedSize == requestedSize, static_cast<FwAssertArgType>(requestedSize),
-              static_cast<FwAssertArgType>(receivedSize));
+    if (status == Fw::FW_SERIALIZE_OK) {
+        const bool omitLength = true;
+        const FwSizeType requestedSize = sizeof this->m_userData;
+        FwSizeType receivedSize = requestedSize;
+        status = serializeRepr.deserialize(this->m_userData, receivedSize, omitLength);
+        if (receivedSize != requestedSize) {
+            status = Fw::FW_DESERIALIZE_SIZE_MISMATCH;
+        }
+    }
     // Deserialize the data product state
-    status = serializeRepr.deserialize(this->m_dpState);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
+    if (status == Fw::FW_SERIALIZE_OK) {
+        status = serializeRepr.deserialize(this->m_dpState);
+    }
     // Deserialize the data size
-    status = serializeRepr.deserialize(this->m_dataSize);
-    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
+    if (status == Fw::FW_SERIALIZE_OK) {
+        status = serializeRepr.deserialize(this->m_dataSize);
+    }
+    return status;
 }
 
 void DpContainer::serializeHeader() {

Fw/Dp/DpContainer.hpp

@@ -103,7 +103,8 @@ class DpContainer {
 
     //! Deserialize the header from the packet buffer
     //! Buffer must be valid and large enough to hold a DP container packet
-    void deserializeHeader();
+    //! \return The serialize status
+    Fw::SerializeStatus deserializeHeader();
 
     //! Serialize the header into the packet buffer and update the header hash
     //! Buffer must be valid and large enough to hold a DP container packet

Fw/Dp/test/ut/TestMain.cpp

@@ -59,7 +59,8 @@ void checkHeader(FwDpIdType id, Fw::Buffer& buffer, DpContainer& container) {
     // Test deserialization: Deserialize the header into a new container
     DpContainer deserContainer;
     deserContainer.setBuffer(container.getBuffer());
-    deserContainer.deserializeHeader();
+    const Fw::SerializeStatus serialStatus = deserContainer.deserializeHeader();
+    ASSERT_EQ(serialStatus, Fw::FW_SERIALIZE_OK);
     // Clear out the header in the buffer
     FW_ASSERT(buffer.isValid());
     ::memset(buffer.getData(), 0, DpContainer::Header::SIZE);
@@ -121,6 +122,24 @@ TEST(Header, BufferSet) {
     checkBuffers(container, sizeof bufferData);
 }
 
+TEST(Header, BadPacketDescriptor) {
+    COMMENT("Test header serialization with bad packet descriptor");
+    // Create a buffer
+    Fw::Buffer buffer(bufferData, sizeof bufferData);
+    // Set the packet descriptor to a bad value
+    Fw::SerializeBufferBase& serialRepr = buffer.getSerializeRepr();
+    const FwPacketDescriptorType badPacketDescriptor = Fw::ComPacket::FW_PACKET_DP + 1;
+    Fw::SerializeStatus status = serialRepr.serialize(badPacketDescriptor);
+    ASSERT_EQ(status, Fw::FW_SERIALIZE_OK);
+    // Use the buffer to create a container
+    DpContainer container;
+    container.setBuffer(buffer);
+    // Deserialize the header
+    const Fw::SerializeStatus serialStatus = container.deserializeHeader();
+    // Check the error
+    ASSERT_EQ(serialStatus, Fw::FW_SERIALIZE_FORMAT_ERROR);
+}
+
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
     STest::Random::seed();