Os static analysis findings

Os/Cpu.hpp

@@ -27,7 +27,7 @@
     CpuInterface(const CpuInterface& other) = delete;
 
     //! \brief assignment operator is forbidden
-    virtual CpuInterface& operator=(const CpuInterface& other) = delete;
+    virtual CpuInterface& operator=(const CpuInterface& other) = delete; // NOSONAR (cpp:S3657)
 
     //! \brief Request the count of the CPUs detected by the system
     //!

Os/File.cpp

@@ -265,7 +265,7 @@ File::Status File::readline(U8* buffer, FwSizeType& size, File::WaitType wait) {
         size = 0;
         return File::Status::INVALID_MODE;
     }
-    FwSizeType original_location;
+    FwSizeType original_location = 0;
     File::Status status = this->position(original_location);
     if (status != Os::File::Status::OP_OK) {
         size = 0;

Os/FileSystem.hpp

@@ -57,7 +57,7 @@
     FileSystemInterface(const FileSystemInterface& other) = delete;
 
     //! \brief assignment operator is forbidden
-    FileSystemInterface& operator=(const FileSystemInterface& other) = delete;
+    FileSystemInterface& operator=(const FileSystemInterface& other) = delete; // NOSONAR (cpp:S3657)
 
     //! \brief return the underlying FileSystem handle (implementation specific)
     //! \return internal FileSystem handle representation

Os/Generic/PriorityQueue.cpp

@@ -64,6 +64,9 @@ QueueInterface::Status PriorityQueue::create(FwEnumStoreType id,
     U8* data = nullptr;
     U8* heap_pointer = nullptr;
 
+    // Prevent integer overflow when computing allocation size (depth * sizeof(FwSizeType))
+    FW_ASSERT(depth < std::numeric_limits<FwSizeType>::max() / sizeof(FwSizeType));
+
     // Allocate indices list and construct it when valid
     size = depth * sizeof(FwSizeType);
     allocation = allocator.allocate(identifier, size, alignof(FwSizeType));

Os/Generic/Types/MaxHeap.cpp

@@ -41,7 +41,7 @@ MaxHeap::~MaxHeap() {
 
 void MaxHeap::create(FwSizeType capacity, Fw::ByteArray heap_allocation) {
     FW_ASSERT(this->m_heap == nullptr);
-    FW_ASSERT(heap_allocation.size >= (capacity * sizeof(Node)), static_cast<FwAssertArgType>(capacity),
+    FW_ASSERT((heap_allocation.size / sizeof(Node)) >= capacity, static_cast<FwAssertArgType>(capacity),
               static_cast<FwAssertArgType>(heap_allocation.size));
     FW_ASSERT(heap_allocation.bytes != nullptr);
     // Loop bounds will overflow if capacity set to the max allowable value

Os/Memory.hpp

@@ -24,7 +24,7 @@
     virtual ~MemoryInterface() = default;
 
     //! \brief copy constructor is forbidden
-    MemoryInterface(const MemoryInterface& other) = delete;
+    MemoryInterface(const MemoryInterface& other) = delete; // NOSONAR (cpp:S3657)
 
     //! \brief assignment operator is forbidden
     virtual MemoryInterface& operator=(const MemoryInterface& other) = delete;

Os/Queue.hpp

@@ -61,7 +61,7 @@
     QueueInterface(const QueueInterface* other) = delete;
 
     //! \brief assignment operator is forbidden
-    virtual QueueInterface& operator=(const QueueInterface& other) = delete;
+    virtual QueueInterface& operator=(const QueueInterface& other) = delete; // NOSONAR (cpp:S3657)
 
     //! \brief create queue storage
     //!