Fixed formatting errors

bitWarrior · bitWarrior · commit b5131ad0eaed · 2026-04-22T14:00:09.000-07:00
diff --git a/Fw/Dp/DpContainer.cpp b/Fw/Dp/DpContainer.cpp
@@ -70,7 +70,8 @@ Fw::SerializeStatus DpContainer::deserializeHeader() {
     if (status == Fw::FW_SERIALIZE_OK) {
         const FwSizeType requestedSize = sizeof this->m_userData;
         FwSizeType receivedSize = requestedSize;
-        status = deserializer.deserializeTo(this->m_userData, sizeof(this->m_userData), receivedSize, Fw::Serialization::OMIT_LENGTH);
+        status = deserializer.deserializeTo(this->m_userData, sizeof(this->m_userData), receivedSize,
+                                            Fw::Serialization::OMIT_LENGTH);
         if (receivedSize != requestedSize) {
             status = Fw::FW_DESERIALIZE_SIZE_MISMATCH;
         }
diff --git a/Fw/Dp/test/util/DpContainerHeader.hpp b/Fw/Dp/test/util/DpContainerHeader.hpp
@@ -74,7 +74,8 @@ struct DpContainerHeader {
         // Deserialize the user data
         DpContainerHeader::moveDeserToOffset(file, line, deserializer, DpContainer::Header::USER_DATA_OFFSET);
         FwSizeType size = sizeof this->m_userData;
-        status = deserializer.deserializeTo(this->m_userData, sizeof(this->m_userData), size, Fw::Serialization::OMIT_LENGTH);
+        status = deserializer.deserializeTo(this->m_userData, sizeof(this->m_userData), size,
+                                            Fw::Serialization::OMIT_LENGTH);
         DP_CONTAINER_HEADER_ASSERT_EQ(status, FW_SERIALIZE_OK);
         DP_CONTAINER_HEADER_ASSERT_EQ(size, sizeof this->m_userData);
         // Deserialize the data product state
diff --git a/Fw/Log/AmpcsEvrLogPacket.cpp b/Fw/Log/AmpcsEvrLogPacket.cpp
@@ -69,7 +69,8 @@ SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerialBufferBase& buffer) {
     }
 
     FwSizeType size = buffer.getDeserializeSizeLeft();
-    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), this->m_logBuffer.getCapacity(), size, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), this->m_logBuffer.getCapacity(), size,
+                                Fw::Serialization::OMIT_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_logBuffer.setBuffLen(size);
diff --git a/Fw/Log/LogPacket.cpp b/Fw/Log/LogPacket.cpp
@@ -54,7 +54,8 @@ SerializeStatus LogPacket::deserializeFrom(SerialBufferBase& buffer, Fw::Endiann
 
     // remainder of buffer must be telemetry value
     FwSizeType size = buffer.getDeserializeSizeLeft();
-    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), this->m_logBuffer.getCapacity(), size, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), this->m_logBuffer.getCapacity(), size,
+                                Fw::Serialization::OMIT_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_logBuffer.setBuffLen(size);
diff --git a/Fw/Tlm/TlmPacket.cpp b/Fw/Tlm/TlmPacket.cpp
@@ -110,7 +110,8 @@ SerializeStatus TlmPacket::extractValue(FwChanIdType& id, Time& timeTag, TlmBuff
     }
 
     // telemetry buffer
-    stat = this->m_tlmBuffer.deserializeTo(buffer.getBuffAddr(), buffer.getCapacity(), bufferSize, Fw::Serialization::OMIT_LENGTH);
+    stat = this->m_tlmBuffer.deserializeTo(buffer.getBuffAddr(), buffer.getCapacity(), bufferSize,
+                                           Fw::Serialization::OMIT_LENGTH);
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
@@ -142,7 +143,8 @@ SerializeStatus TlmPacket::deserializeFrom(SerialBufferBase& buffer, Fw::Endiann
     }
     // deserialize the channel value entry buffers
     FwSizeType size = buffer.getDeserializeSizeLeft();
-    stat = buffer.deserializeTo(this->m_tlmBuffer.getBuffAddr(), this->m_tlmBuffer.getCapacity(), size, Fw::Serialization::OMIT_LENGTH);
+    stat = buffer.deserializeTo(this->m_tlmBuffer.getBuffAddr(), this->m_tlmBuffer.getCapacity(), size,
+                                Fw::Serialization::OMIT_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         // Shouldn't fail
         stat = this->m_tlmBuffer.setBuffLen(size);
diff --git a/Fw/Types/SerialBuffer.hpp b/Fw/Types/SerialBuffer.hpp
@@ -59,9 +59,9 @@ class SerialBuffer final : public LinearBufferBase {
     );
 
     //! Pop n bytes off the buffer
-    SerializeStatus popBytes(U8* const addr,       //!< Address of bytes to pop
+    SerializeStatus popBytes(U8* const addr,           //!< Address of bytes to pop
                              FwSizeType buffCapacity,  //!< Capacity in bytes of addr
-                             FwSizeType n          //!< Number of bytes to pop
+                             FwSizeType n              //!< Number of bytes to pop
     );
 
   private:
diff --git a/Fw/Types/Serializable.cpp b/Fw/Types/Serializable.cpp
@@ -520,7 +520,8 @@ SerializeStatus LinearBufferBase::deserializeTo(U8* buff,
                                                 Serializable::SizeType& length,
                                                 Endianness endianMode) {
     FwSizeType length_in_out = static_cast<FwSizeType>(length);
-    SerializeStatus status = this->deserializeTo(buff, buffCapacity, length_in_out, Serialization::INCLUDE_LENGTH, endianMode);
+    SerializeStatus status =
+        this->deserializeTo(buff, buffCapacity, length_in_out, Serialization::INCLUDE_LENGTH, endianMode);
     length = static_cast<Serializable::SizeType>(length_in_out);
     return status;
 }
diff --git a/Fw/Types/Serializable.hpp b/Fw/Types/Serializable.hpp
@@ -1334,12 +1334,14 @@ class LinearBufferBase : public SerialBufferBase {
     DEPRECATED(SerializeStatus deserialize(F64& val), "Use deserializeTo(F64& val) instead");
     DEPRECATED(SerializeStatus deserialize(bool& val), "Use deserializeTo(bool& val) instead");
     DEPRECATED(SerializeStatus deserialize(void*& val), "Use deserializeTo(void*& val) instead");
-    DEPRECATED(SerializeStatus deserialize(U8* buff, FwSizeType& length, bool noLength),
-               "Use deserializeTo(U8* buff, FwSizeType buffCapacity, FwSizeType& length, Serialization::t mode) instead");
+    DEPRECATED(
+        SerializeStatus deserialize(U8* buff, FwSizeType& length, bool noLength),
+        "Use deserializeTo(U8* buff, FwSizeType buffCapacity, FwSizeType& length, Serialization::t mode) instead");
     DEPRECATED(SerializeStatus deserialize(U8* buff, FwSizeType& length),
                "Use deserializeTo(U8* buff, FwSizeType buffCapacity, FwSizeType& length) instead");
-    DEPRECATED(SerializeStatus deserialize(U8* buff, FwSizeType& length, Serialization::t mode),
-               "Use deserializeTo(U8* buff, FwSizeType buffCapacity, FwSizeType& length, Serialization::t mode) instead");
+    DEPRECATED(
+        SerializeStatus deserialize(U8* buff, FwSizeType& length, Serialization::t mode),
+        "Use deserializeTo(U8* buff, FwSizeType buffCapacity, FwSizeType& length, Serialization::t mode) instead");
     DEPRECATED(SerializeStatus deserialize(Serializable& val), "Use deserializeTo(Serializable& val) instead");
 
 #ifdef BUILD_UT
diff --git a/Fw/Types/StringBase.cpp b/Fw/Types/StringBase.cpp
@@ -103,7 +103,8 @@ SerializeStatus StringBase::deserializeFrom(SerialBufferBase& buffer, Fw::Endian
     // Deserialize length
     // Fail if length exceeds max size (the initial value of actualSize)
     // Otherwise deserialize length bytes and set actualSize to length
-    SerializeStatus stat = buffer.deserializeTo(reinterpret_cast<U8*>(raw), static_cast<FwSizeType>(maxSize), actualSize, Serialization::INCLUDE_LENGTH);
+    SerializeStatus stat = buffer.deserializeTo(reinterpret_cast<U8*>(raw), static_cast<FwSizeType>(maxSize),
+                                                actualSize, Serialization::INCLUDE_LENGTH);
     if (stat == FW_SERIALIZE_OK) {
         // Deserialization succeeded: null-terminate string at actual size
         FW_ASSERT(actualSize <= maxSize, static_cast<FwAssertArgType>(actualSize),
diff --git a/Svc/Ccsds/SpacePacketFramer/test/ut/SpacePacketFramerTester.cpp b/Svc/Ccsds/SpacePacketFramer/test/ut/SpacePacketFramerTester.cpp
@@ -82,33 +82,32 @@ void SpacePacketFramerTester::testNominalFraming() {
 }
 
 void SpacePacketFramerTester ::testOversizedAllocatorBufferIsTrimmed() {
-   U8 payload[16];
+    U8 payload[16];
     for (U32 i = 0; i < sizeof(payload); ++i) {
         payload[i] = static_cast<U8>(STest::Random::lowerUpper(0, 0xFF));
     }
     Fw::Buffer data(payload, sizeof(payload));
     ComCfg::FrameContext context;
     context.set_apid(static_cast<ComCfg::Apid::T>(0x01));
     this->m_nextSeqCount = 0;
- 
+
     // Signal the allocator handler to return a larger-than-needed buffer,
     // simulating a BufferManager bin that is bigger than the exact packet size.
     this->m_useOversizedAlloc = true;
     this->invoke_to_dataIn(0, data, context);
     this->m_useOversizedAlloc = false;
- 
+
     ASSERT_from_dataOut_SIZE(1);
     ASSERT_from_dataReturnOut_SIZE(1);
- 
+
     const FwSizeType expectedFrameSize = sizeof(payload) + SpacePacketHeader::SERIALIZED_SIZE;
- 
+
     Fw::Buffer outBuffer = this->fromPortHistory_dataOut->at(0).data;
     // If setSize() is missing from SpacePacketFramer, getSize() returns the
     // oversized allocation (2 * expectedFrameSize) and this assertion fails.
     ASSERT_EQ(outBuffer.getSize(), expectedFrameSize);
 }
 
-
 // ----------------------------------------------------------------------
 // Output port handler overrides
 // ----------------------------------------------------------------------
diff --git a/Svc/CmdSequencer/FPrimeSequence.cpp b/Svc/CmdSequencer/FPrimeSequence.cpp
@@ -299,7 +299,8 @@ Fw::SerializeStatus CmdSequencerComponentImpl::FPrimeSequence ::copyCommand(Fw::
     FwSizeType size = recordSize;
     Fw::SerializeStatus status = comBuffer.setBuffLen(recordSize);
     FW_ASSERT(status == Fw::FW_SERIALIZE_OK, status);
-    status = buffer.deserializeTo(comBuffer.getBuffAddr(), comBuffer.getCapacity(), size, Fw::Serialization::OMIT_LENGTH);
+    status =
+        buffer.deserializeTo(comBuffer.getBuffAddr(), comBuffer.getCapacity(), size, Fw::Serialization::OMIT_LENGTH);
     return status;
 }
 
diff --git a/Svc/CmdSequencer/formats/AMPCSSequence.cpp b/Svc/CmdSequencer/formats/AMPCSSequence.cpp
@@ -338,7 +338,8 @@ Fw::SerializeStatus AMPCSSequence ::translateCommand(Fw::ComBuffer& comBuffer, c
     U8* const addr = comBuffer.getBuffAddr();
     FW_ASSERT(addr != nullptr);
     // true means "don't serialize the length"
-    status = buffer.deserializeTo(&addr[fixedBuffLen], comBuffer.getCapacity() - fixedBuffLen, size, Fw::Serialization::OMIT_LENGTH);
+    status = buffer.deserializeTo(&addr[fixedBuffLen], comBuffer.getCapacity() - fixedBuffLen, size,
+                                  Fw::Serialization::OMIT_LENGTH);
     return status;
 }
 
diff --git a/Svc/DpCatalog/DpCatalog.cpp b/Svc/DpCatalog/DpCatalog.cpp
@@ -204,18 +204,16 @@ Fw::CmdResponse DpCatalog::loadStateFile() {
         // the source buffer was specifically sized to hold the data
 
         // Deserialize the file directory index. If an error occurs processing the file,
-        // generate event and return EXECUTION_ERROR. 
+        // generate event and return EXECUTION_ERROR.
         Fw::SerializeStatus status = entryBuffer.deserializeTo(this->m_stateFileData[entry].entry.dir);
         if (status != Fw::FW_SERIALIZE_OK) {
-            this->log_WARNING_HI_FileCorruptedDataError
-                (this->m_stateFile, static_cast<I32>(status));
+            this->log_WARNING_HI_FileCorruptedDataError(this->m_stateFile, static_cast<I32>(status));
             stateFile.close();
             return Fw::CmdResponse::EXECUTION_ERROR;
         }
         status = entryBuffer.deserializeTo(this->m_stateFileData[entry].entry.record);
         if (status != Fw::FW_SERIALIZE_OK) {
-            this->log_WARNING_HI_FileCorruptedDataError
-                (this->m_stateFile, static_cast<I32>(status));
+            this->log_WARNING_HI_FileCorruptedDataError(this->m_stateFile, static_cast<I32>(status));
             stateFile.close();
             return Fw::CmdResponse::EXECUTION_ERROR;
         }
diff --git a/Svc/DpCatalog/test/ut/DpCatalogTester.cpp b/Svc/DpCatalog/test/ut/DpCatalogTester.cpp
@@ -757,17 +757,16 @@ void DpCatalogTester::test_ProcessFileInvalidDir() {
 }
 
 void DpCatalogTester::test_MalformedFile() {
-
     // 1. Setup paths and corrupted data
     Fw::FileNameString stateFile("DpState.dat");
-    
+
     BYTE buffer[sizeof(FwIndexType) + DpRecord::SERIALIZED_SIZE];
-    memset(buffer, 0xFF, sizeof(buffer)); // Force deserialization failure
+    memset(buffer, 0xFF, sizeof(buffer));  // Force deserialization failure
 
     // 2. Write the malformed data to disk
     Os::File f;
     ASSERT_EQ(Os::File::OP_OK, f.open(stateFile.toChar(), Os::File::OPEN_CREATE, Os::FileInterface::OVERWRITE));
-    
+
     FwSizeType writeSize = sizeof(buffer);
     ASSERT_EQ(Os::File::OP_OK, f.write(buffer, writeSize));
     f.close();
@@ -783,16 +782,12 @@ void DpCatalogTester::test_MalformedFile() {
 
     // 5. Command should generate event instead of ASSERT
     ASSERT_CMD_RESPONSE_SIZE(1);
-    //ASSERT_CMD_RESPONSE(0, DpCatalogComponentBase::OPCODE_BUILD_CATALOG, 0, Fw::CmdResponse::EXECUTION_ERROR);
+    // ASSERT_CMD_RESPONSE(0, DpCatalogComponentBase::OPCODE_BUILD_CATALOG, 0, Fw::CmdResponse::EXECUTION_ERROR);
 
     // High-priority warning event should be caught by this test
     ASSERT_EVENTS_SIZE(2);
     ASSERT_EVENTS_FileCorruptedDataError_SIZE(1);
-    ASSERT_EVENTS_FileCorruptedDataError(
-        0, 
-        stateFile.toChar(), 
-        static_cast<I32>(Fw::FW_DESERIALIZE_FORMAT_ERROR)
-    );
+    ASSERT_EVENTS_FileCorruptedDataError(0, stateFile.toChar(), static_cast<I32>(Fw::FW_DESERIALIZE_FORMAT_ERROR));
 
     // 6. Cleanup
     Os::FileSystem::removeFile(stateFile.toChar());
diff --git a/Svc/FprimeFramer/test/ut/FprimeFramerTester.cpp b/Svc/FprimeFramer/test/ut/FprimeFramerTester.cpp
@@ -79,28 +79,26 @@ void FprimeFramerTester ::testNominalFraming() {
 }
 
 void FprimeFramerTester ::testOversizedAllocatorBufferIsTrimmed() {
-
     U8 bufferData[100];
     Fw::Buffer buffer(bufferData, sizeof(bufferData));
     ComCfg::FrameContext context;
- 
+
     for (U32 i = 0; i < sizeof(bufferData); ++i) {
         bufferData[i] = static_cast<U8>(i);
     }
- 
+
     // Signal the allocator handler to return a larger-than-needed buffer,
     // simulating a BufferManager bin that is bigger than the exact frame size.
     this->m_useOversizedAlloc = true;
     this->invoke_to_dataIn(0, buffer, context);
     this->m_useOversizedAlloc = false;
- 
+
     ASSERT_from_dataOut_SIZE(1);
     ASSERT_from_dataReturnOut_SIZE(1);
- 
-    const FwSizeType expectedFrameSize = sizeof(bufferData) +
-                                         FprimeProtocol::FrameHeader::SERIALIZED_SIZE +
+
+    const FwSizeType expectedFrameSize = sizeof(bufferData) + FprimeProtocol::FrameHeader::SERIALIZED_SIZE +
                                          FprimeProtocol::FrameTrailer::SERIALIZED_SIZE;
- 
+
     Fw::Buffer outputBuffer = this->fromPortHistory_dataOut->at(0).data;
     // If setSize() is missing from FprimeFramer, getSize() returns the
     // oversized allocation (2 * expectedFrameSize) and this assertion fails.
diff --git a/Svc/FpySequencer/FpySequencerRunState.cpp b/Svc/FpySequencer/FpySequencerRunState.cpp
@@ -301,8 +301,8 @@ Fw::Success FpySequencer::deserializeDirective(const Fpy::Statement& stmt, Direc
             }
 
             // okay, it will fit. put it in
-            status =
-                argBuf.deserializeTo(deserializedDirective.pushVal.get_val(), Fpy::MAX_DIRECTIVE_SIZE, bufSize, Fw::Serialization::OMIT_LENGTH);
+            status = argBuf.deserializeTo(deserializedDirective.pushVal.get_val(), Fpy::MAX_DIRECTIVE_SIZE, bufSize,
+                                          Fw::Serialization::OMIT_LENGTH);
 
             if (status != Fw::SerializeStatus::FW_SERIALIZE_OK) {
                 this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
diff --git a/Svc/PrmDb/PrmDbImpl.cpp b/Svc/PrmDb/PrmDbImpl.cpp
@@ -153,8 +153,7 @@ void PrmDbImpl::PRM_SAVE_FILE_cmdHandler(FwOpcodeType opCode, U32 cmdSeq) {
     Os::File paramFile;
     WorkingBuffer buff;
 
-    Os::File::Status stat = paramFile.open
-          (this->m_fileName.toChar(), Os::File::OPEN_WRITE, Os::File::OVERWRITE);
+    Os::File::Status stat = paramFile.open(this->m_fileName.toChar(), Os::File::OPEN_WRITE, Os::File::OVERWRITE);
     if (stat != Os::File::OP_OK) {
         this->log_WARNING_HI_PrmFileWriteError(PrmWriteError::OPEN, 0, stat);
         this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,8 @@ SerializeStatus AmpcsEvrLogPacket::deserializeFrom(SerialBufferBase& buffer) {`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`FwSizeType size = buffer.getDeserializeSizeLeft();`
`72`		`- stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), this->m_logBuffer.getCapacity(), size, Fw::Serialization::OMIT_LENGTH);`
	`72`	`+ stat = buffer.deserializeTo(this->m_logBuffer.getBuffAddr(), this->m_logBuffer.getCapacity(), size,`
	`73`	`+ Fw::Serialization::OMIT_LENGTH);`
`73`	`74`	`if (stat == FW_SERIALIZE_OK) {`
`74`	`75`	`// Shouldn't fail`
`75`	`76`	`stat = this->m_logBuffer.setBuffLen(size);`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,8 @@ SerializeStatus TlmPacket::extractValue(FwChanIdType& id, Time& timeTag, TlmBuff`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`// telemetry buffer`
`113`		`- stat = this->m_tlmBuffer.deserializeTo(buffer.getBuffAddr(), buffer.getCapacity(), bufferSize, Fw::Serialization::OMIT_LENGTH);`
	`113`	`+ stat = this->m_tlmBuffer.deserializeTo(buffer.getBuffAddr(), buffer.getCapacity(), bufferSize,`
	`114`	`+ Fw::Serialization::OMIT_LENGTH);`
`114`	`115`	`if (stat != Fw::FW_SERIALIZE_OK) {`
`115`	`116`	`return stat;`
`116`	`117`	`}`
`@@ -142,7 +143,8 @@ SerializeStatus TlmPacket::deserializeFrom(SerialBufferBase& buffer, Fw::Endiann`
`142`	`143`	`}`
`143`	`144`	`// deserialize the channel value entry buffers`
`144`	`145`	`FwSizeType size = buffer.getDeserializeSizeLeft();`
`145`		`- stat = buffer.deserializeTo(this->m_tlmBuffer.getBuffAddr(), this->m_tlmBuffer.getCapacity(), size, Fw::Serialization::OMIT_LENGTH);`
	`146`	`+ stat = buffer.deserializeTo(this->m_tlmBuffer.getBuffAddr(), this->m_tlmBuffer.getCapacity(), size,`
	`147`	`+ Fw::Serialization::OMIT_LENGTH);`
`146`	`148`	`if (stat == FW_SERIALIZE_OK) {`
`147`	`149`	`// Shouldn't fail`
`148`	`150`	`stat = this->m_tlmBuffer.setBuffLen(size);`