add additional warnings to the library build and misc clean up

switch to ubuntu 24.04 for github build

Author: mattheweshleman

.github/workflows/cmake.yml

@@ -12,10 +12,10 @@ env:
 
 jobs:
   build:
-    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # The CMake configure and build commands are platform-agnostic and should work equally well on Windows or Mac.
     # You can convert this to a matrix build if you need cross-platform coverage.
     # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
 
     steps:
     - uses: actions/checkout@v3

cpputest-for-qpc-lib/CMakeLists.txt

@@ -16,6 +16,8 @@ add_library(cpputest-for-qpc-lib
 target_link_libraries(cpputest-for-qpc-lib qassert-meta-lib)
 add_subdirectory(tests)
 
+target_compile_options(cpputest-for-qpc-lib PRIVATE -Wall -Wextra -Werror -Wpedantic -Wsign-conversion)
+
 target_include_directories(cpputest-for-qpc-lib PUBLIC
         ${CMS_QPC_INCLUDE_DIR}
         include)

cpputest-for-qpc-lib/include/cmsTestPublishedEventRecorder.hpp

@@ -29,7 +29,6 @@
 #include "cmsDummyActiveObject.hpp"
 #include "cmsVectorBackedQEQueue.hpp"
 #include "qevtUniquePtr.hpp"
-#include <vector>
 
 namespace cms {
 namespace test {
@@ -60,7 +59,7 @@ class PublishedEventRecorder final : public DefaultDummyActiveObject {
 
     /// Upon construction and init/start, this active object will
     /// subscribe and record all events in the signal range:
-    ///         [startingValue .. endValue)
+    ///         [startingValue ... endValue)
     /// \param startingValue - starting sig value the recorder will record
     /// \param endValue - final value in sig range to record. This value is
     ///                   NOT recorded, rather "endValue - 1" is recorded.
@@ -102,11 +101,11 @@ class PublishedEventRecorder final : public DefaultDummyActiveObject {
         }
     }
 
-    bool isEmpty() { return m_recordedEvents.isEmpty(); }
+    bool isEmpty() const { return m_recordedEvents.isEmpty(); }
 
-    bool isAnyEventRecorded() { return !m_recordedEvents.isEmpty(); }
+    bool isAnyEventRecorded() const { return !m_recordedEvents.isEmpty(); }
 
-    bool isSignalRecorded(enum_t sig)
+    bool isSignalRecorded(const enum_t sig)
     {
         if (!isAnyEventRecorded()) {
             return false;
@@ -117,10 +116,10 @@ class PublishedEventRecorder final : public DefaultDummyActiveObject {
         return recordedSig == sig;
     }
 
-    cms::QEvtUniquePtr getRecordedEvent()
+    QEvtUniquePtr getRecordedEvent()
     {
         if (!isAnyEventRecorded()) {
-            return cms::QEvtUniquePtr();
+            return {};
         }
 
         return cms::QEvtUniquePtr(m_recordedEvents.get());

cpputest-for-qpc-lib/include/cms_cpputest_qf_ctrl.hpp

@@ -99,7 +99,7 @@ void PublishEvent(QEvt const * e);
 /// Publish a trivial QEvt event to the QF framework followed internally
 /// by ProcessEvents().
 /// \param sig
-/// \param recorder, if provided, will automatically ensure the published
+/// \param recorder if provided, will automatically ensure the published
 ///                  event is ignored by the recorder.
 void PublishAndProcess(enum_t sig,
                        PublishedEventRecorder* recorder = nullptr);

cpputest-for-qpc-lib/include/qevtUniquePtr.hpp

@@ -31,8 +31,8 @@ namespace cms {
 
 /// I love a nice RAII pattern, such as std::unique_ptr.
 /// A QEvt may have been allocated from an event pool, which must be
-/// garbage collected. This is easy to forget, and is therefore more error
-/// prone, especially when deferring events or recording events. This
+/// garbage collected. This is easy to forget, and is therefore more
+/// error-prone, especially when deferring events or recording events. This
 /// class helps guarantee that the event is appropriately garbage collected.
 ///
 /// https://covemountainsoftware.com/2019/11/26/why-i-prefer-c-raii-all-the-things/
@@ -53,7 +53,7 @@ class QEvtUniquePtr {
         }
     }
 
-    QEvtUniquePtr(QEvtUniquePtr&& o) noexcept : m_evt(std::move(o.m_evt))
+    QEvtUniquePtr(QEvtUniquePtr&& o) noexcept : m_evt(o.m_evt)
     {
         o.m_evt = nullptr;
     }
@@ -69,7 +69,7 @@ class QEvtUniquePtr {
 
     bool operator!=(void* ptr) const { return ptr != m_evt; }
 
-    const QEvt* get() noexcept { return m_evt; }
+    const QEvt* get() const noexcept { return m_evt; }
 
 private:
     QEvt const* m_evt;

cpputest-for-qpc-lib/src/cms_cpputest_q_onAssert.cpp

@@ -1,5 +1,5 @@
 /// @brief Provides an implementation of the required QP function
-/// Q_onAssert(..).
+/// Q_onAssert(...).
 ///        This implementation uses cpputest mock and the TEST_EXIT macro
 ///        which throws an exception. This will generally not work in most
 ///        of QP, as most methods are marked noexcept.

cpputest-for-qpc-lib/src/cms_cpputest_qf_ctrl.cpp

@@ -68,7 +68,7 @@ void Setup(enum_t const maxPubSubSignalValue, uint32_t ticksPerSecond,
     l_memPoolOption     = memPoolOpt;
     l_ticksPerSecond    = ticksPerSecond;
     l_subscriberStorage = new SubscriberList();
-    l_subscriberStorage->resize(maxPubSubSignalValue);
+    l_subscriberStorage->resize(static_cast<size_t>(maxPubSubSignalValue));
     QSubscrList nullValue;
     QPSet_setEmpty(&nullValue.set);
     QPSet_setEmpty(&nullValue.set_dis);

cpputest-for-qpc-lib/src/cpputest_qf_port.cpp

@@ -41,7 +41,7 @@ extern "C" void QF_init(void)
          ++tickRate)
     {
         QTimeEvt_ctorX(&QTimeEvt_timeEvtHead_[tickRate],
-                       (QActive *)0, Q_USER_SIG, tickRate);
+                       nullptr, Q_USER_SIG, tickRate);
     }
 
     bzero(&QActive_registry_[0], static_cast<uint_fast16_t>(sizeof(QActive_registry_)));