Update project to use latest QP/C v7.3.3.

Author: mattheweshleman

examples/hwLockCtrlService/CMakeLists.txt

@@ -5,5 +5,6 @@ target_link_libraries(hwLockCtrlService hwLockCtrl)
 target_include_directories(hwLockCtrlService PUBLIC include)
 
 # TODO: setting up QP should probably be a higher level build option
+add_compile_definitions(QACTIVE_CAN_STOP)
 include_directories(${QP_CPP_INCLUDE_DIR})
 include(${EXTERNALS_TOP_DIR}/qpcPosixPortCMakeSupport.txt)

examples/hwLockCtrlService/src/hwLockCtrlService.c

@@ -25,11 +25,10 @@
 
 #include "hwLockCtrlService.h"
 #include "hwLockCtrl.h"
-#include "pub_sub_signals.h"
 #include "hwLockCtrlSelfTestEvent.h"
 #include "pingPongEvents.h"
 #include "bspTicks.h"
-#include "qassert.h"
+#include "qsafe.h"
 #include <stddef.h>
 
 Q_DEFINE_THIS_FILE
@@ -95,11 +94,7 @@ void HwLockCtrlService_ctor()
 
 void HwLockCtrlService_dtor()
 {
-    static const QEvt selfDestructEvent = {
-      SERVICE_DESTRUCTOR_SIG,
-      0U,
-      0U
-    };
+    static QEvt const selfDestructEvent = QEVT_INITIALIZER(SERVICE_DESTRUCTOR_SIG);
 
     Q_ASSERT(g_theHwLockCtrlService != NULL);
 
@@ -291,7 +286,8 @@ void PerformSelfTest(HwLockCtrlService * const me)
     //
     //  https://covemountainsoftware.com/2020/03/08/uml-statechart-handling-errors-when-entering-a-state/
     //
-    static const QEvt event = {REQUEST_GOTO_HISTORY_SIG, 0U, 0U};
+    static QEvt const event = QEVT_INITIALIZER(REQUEST_GOTO_HISTORY_SIG);
+
     QACTIVE_POST_LIFO(&me->super, &event);
 }
 
@@ -300,17 +296,8 @@ void NotifyChangedState(HwLockCtrlService * const me, HwLockCtrlLockState state)
     (void)me; //the QF_PUBLISH macro may not be using that member
               //in some build configurations
 
-    static const QEvt lockedEvent = {
-      HW_LOCK_CTRL_SERVICE_IS_LOCKED_SIG,
-      0U,
-      0U
-    };
-
-    static const QEvt unlockedEvent = {
-      HW_LOCK_CTRL_SERVICE_IS_UNLOCKED_SIG,
-      0U,
-      0U
-    };
+    static QEvt const lockedEvent = QEVT_INITIALIZER(HW_LOCK_CTRL_SERVICE_IS_LOCKED_SIG);
+    static QEvt const unlockedEvent = QEVT_INITIALIZER(HW_LOCK_CTRL_SERVICE_IS_UNLOCKED_SIG);
 
     switch (state) {
         case LOCK_STATE_LOCKED:

examples/hwLockCtrlService/test/hwLockCtrlServiceTests.cpp

@@ -27,7 +27,6 @@
 #include <chrono>
 #include "qpc.h"
 #include "hwLockCtrl.h"
-#include "pub_sub_signals.h"
 #include "hwLockCtrlService.h"
 #include "cms_cpputest_qf_ctrl.hpp"
 #include "cmsTestPublishedEventRecorder.hpp"
@@ -414,8 +413,7 @@ TEST(HwLockCtrlServiceTests, the_service_responds_to_a_ping_with_a_pong)
     // to an event with a POST directly to an external requesting AO.
 
     PongEvent pongEvent;
-    pongEvent.super.sig = 0;
-    pongEvent.source    = nullptr;
+    QEvt_ctor(&pongEvent.super, 0);
 
     auto dummy = std::unique_ptr<cms::DefaultDummyActiveObject>(
       new cms::DefaultDummyActiveObject());
@@ -432,9 +430,7 @@ TEST(HwLockCtrlServiceTests, the_service_responds_to_a_ping_with_a_pong)
     // Send the Ping to our AO under test and give it
     // some processing time.
     PingEvent pingEvent;
-    pingEvent.super.sig = HW_LOCK_CTRL_PING_SIG;
-    pingEvent.super.poolId_ = 0;
-    pingEvent.super.refCtr_ = 0;
+    QEvt_ctor(&pingEvent.super, HW_LOCK_CTRL_PING_SIG);
     pingEvent.requester = dummy->getQActive();
     pingEvent.response_sig = RESPONSE_SIG;
 

test_support/cpputest-qpc-port/include/qassertMockSupport.hpp

@@ -24,28 +24,29 @@
 #ifndef QASSERT_MOCK_SUPPORT_HPP
 #define QASSERT_MOCK_SUPPORT_HPP
 
-#include "qassert.h"
+#include "qp_port.h"
+#include "qsafe.h"
 #include "CppUTestExt/MockSupport.h"
 
 namespace cms {
 namespace test {
 
 static constexpr const char* QASSERT_MOCK_NAME  = "QASSERT";
-static constexpr const char* ONASSERT_FUNC_NAME = "Q_onAssert";
+static constexpr const char* ONERROR_FUNC_NAME  = "Q_onError";
 
 inline void MockExpectQAssert()
 {
     mock(QASSERT_MOCK_NAME)
-      .expectOneCall(ONASSERT_FUNC_NAME)
+      .expectOneCall(ONERROR_FUNC_NAME)
       .ignoreOtherParameters();
 }
 
-inline void MockExpectQAssert(const char* file, int loc)
+inline void MockExpectQAssert(const char* module, int id)
 {
     mock(QASSERT_MOCK_NAME)
-      .expectOneCall(ONASSERT_FUNC_NAME)
-      .withParameter("file", file)
-      .withParameter("loc", loc);
+      .expectOneCall(ONERROR_FUNC_NAME)
+      .withParameter("module", module)
+      .withParameter("id", id);
 }
 
 }   // namespace test

test_support/cpputest-qpc-port/include/qep_port.h

@@ -9,6 +9,6 @@
 #include <stdint.h>  /* Exact-width types. WG14/N843 C99 Standard */
 #include <stdbool.h> /* Boolean type.      WG14/N843 C99 Standard */
 
-#include "qep.h"     /* QEP platform-independent public interface */
+#include "qp.h"     /* QEP platform-independent public interface */
 
 #endif   // CPPUTEST_FOR_QPC_QEP_PORT_H

…port/cpputest-qpc-port/include/qf_port.h …port/cpputest-qpc-port/include/qp_port.htest_support/cpputest-qpc-port/include/qf_port.h renamed to test_support/cpputest-qpc-port/include/qp_port.h test_support/cpputest-qpc-port/include/qf_port.h renamed to test_support/cpputest-qpc-port/include/qp_port.h

@@ -25,27 +25,36 @@
 #ifndef CPPUTEST_FOR_QPC_QF_PORT_H
 #define CPPUTEST_FOR_QPC_QF_PORT_H
 
+#include <stdint.h>  // Exact-width types. WG14/N843 C99 Standard
+#include <stdbool.h> // Boolean type.      WG14/N843 C99 Standard
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#define Q_NORETURN  void
+
+#define QACTIVE_EQUEUE_TYPE  QEQueue
+#define QACTIVE_THREAD_TYPE  bool
+
 #define QF_EQUEUE_TYPE      QEQueue
 #define QF_MAX_ACTIVE       64U
 #define QF_MAX_TICK_RATE    2U
-#define QF_ACTIVE_STOP      1
+#define QACTIVE_CAN_STOP      1
 #define QF_EVENT_SIZ_SIZE   4U
 #define QF_EQUEUE_CTR_SIZE  4U
 #define QF_MPOOL_SIZ_SIZE   4U
 #define QF_MPOOL_CTR_SIZE   4U
 #define QF_TIMEEVT_CTR_SIZE 4U
 
+//cpputest port, no critical sections are necessary
+#define QF_CRIT_STAT
 #define QF_CRIT_ENTRY(dummy)
 #define QF_CRIT_EXIT(dummy)
 
-#include "qep_port.h"
 #include "qequeue.h"
 #include "qmpool.h"
-#include "qf.h"
+#include "qp.h"
 
 void QF_runUntilNoReadyActiveObjects(void);
 
@@ -62,15 +71,15 @@ void QF_runUntilNoReadyActiveObjects(void);
         QPSet_insert(&cpputest_readySet_, (me_)->prio); \
     } while (false)
 
-    #define QF_EPOOL_TYPE_ QMPool
+    // native QF event pool operations
+    #define QF_EPOOL_TYPE_  QMPool
     #define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) \
         (QMPool_init(&(p_), (poolSto_), (poolSize_), (evtSize_)))
-    #define QF_EPOOL_EVENT_SIZE_(p_) ((uint_fast16_t)(p_).blockSize)
-    #define QF_EPOOL_GET_(p_, e_, m_, qs_id_) \
-        ((e_) = (QEvt*)QMPool_get(&(p_), (m_), (qs_id_)))
-    #define QF_EPOOL_PUT_(p_, e_, qs_id_) (QMPool_put(&(p_), (e_), (qs_id_)))
-
-    #include "qf_pkg.h"          /* internal QF interface */
+    #define QF_EPOOL_EVENT_SIZE_(p_)  ((uint_fast16_t)(p_).blockSize)
+    #define QF_EPOOL_GET_(p_, e_, m_, qsId_) \
+        ((e_) = (QEvt *)QMPool_get(&(p_), (m_), (qsId_)))
+    #define QF_EPOOL_PUT_(p_, e_, qsId_) \
+        (QMPool_put(&(p_), (e_), (qsId_)))
 
     extern QPSet cpputest_readySet_; /* QV-ready set of active objects */
 

test_support/cpputest-qpc-port/src/cms_cpputest_q_onAssert.cpp

@@ -27,12 +27,13 @@
 /// @endcond
 
 #include "CppUTest/TestHarness.h"
-#include "qassert.h"
+#include "qp_port.h" //required for Q_NORETURN definition, needed by qsafe.h
+#include "qsafe.h"
 #include "qassertMockSupport.hpp"
 
-Q_NORETURN Q_onAssert(char const* const file, int_t const loc)
+void Q_onError(char const* const module, int_t const id)
 {
-    // fprintf(stderr, "%s(%s , %d)\n", __FUNCTION__ , file, loc);
+    //fprintf(stderr, "%s(%s , %d)\n", __FUNCTION__ , module, id);
 
     // The TEST_EXIT macro used below is throwing an exception.
     // However, many of QP/QF methods are marked as 'noexcept'
@@ -46,9 +47,9 @@ Q_NORETURN Q_onAssert(char const* const file, int_t const loc)
     //    the function std::terminate ... is called ..."
     //
     mock(cms::test::QASSERT_MOCK_NAME)
-      .actualCall(cms::test::ONASSERT_FUNC_NAME)
-      .withParameter("file", file)
-      .withParameter("loc", loc);
+      .actualCall(cms::test::ONERROR_FUNC_NAME)
+      .withParameter("module", module)
+      .withParameter("id", id);
 
     TEST_EXIT
 }

test_support/cpputest-qpc-port/src/cms_cpputest_qf_ctrl.cpp

@@ -27,7 +27,6 @@
 #include "cmsTestPublishedEventRecorder.hpp"
 #include <algorithm>
 #include <cassert>
-#include <cstdint>
 #include <vector>
 #include "CppUTest/TestHarness.h"
 
@@ -68,7 +67,9 @@ void Setup(enum_t const maxPubSubSignalValue, uint32_t ticksPerSecond,
     l_ticksPerSecond    = ticksPerSecond;
     l_subscriberStorage = new SubscriberList();
     l_subscriberStorage->resize(maxPubSubSignalValue);
-    QSubscrList nullValue = {0};
+    QSubscrList nullValue;
+    QPSet_setEmpty(&nullValue.set);
+    QPSet_setEmpty(&nullValue.set_dis);
     std::fill(l_subscriberStorage->begin(), l_subscriberStorage->end(),
               nullValue);
 
@@ -132,7 +133,7 @@ void MoveTimeForward(const std::chrono::milliseconds& duration)
       ONCE, static_cast<LoopCounter_t>(duration.count() / millisecondsPerTick));
 
     for (LoopCounter_t i = 0; i < ticks; ++i) {
-        QF_tickX_(0U);
+        QTIMEEVT_TICK_X(0U, nullptr);
         ProcessEvents();
     }
 }

test_support/cpputest-qpc-port/src/cms_cpputest_qf_onCleanup.cpp

@@ -24,11 +24,12 @@
 #define QP_IMPL //allow access to some QF/QP internals for test purposes
 #include "qpc.h"
 #include "CppUTest/TestHarness.h"
+#include "qp_pkg.h"
 
 extern "C" void QF_onCleanup(void)
 {
-    for (int i = 0; i < QF_maxPool_; ++i) {
-        CHECK_TRUE_TEXT(QF_pool_[i].nTot == QF_pool_[i].nFree,
+    for (int i = 0; i < QF_priv_.maxPool_; ++i) {
+        CHECK_TRUE_TEXT(QF_priv_.ePool_[i].nTot == QF_priv_.ePool_[i].nFree,
                         "A leak was detected in an internal QF event pool!");
     }
 }

test_support/cpputest-qpc-port/src/cpputest_qf_port.cpp

@@ -24,73 +24,79 @@
 /// @endcond
 
 #define QP_IMPL //allow access to some QF/QP internals for test purposes
-#include "qf_port.h"      /* QF port */
-#include "qf_pkg.h"
-#include "qassert.h"
+#include "qp_port.h"
+#include "qsafe.h"
+#include "qp_pkg.h"
 #include <cstring>
-#include <cstdint>
 
 Q_DEFINE_THIS_MODULE("cpputest_qf_port")
 
 QPSet  cpputest_readySet_;
 
 extern "C" void QF_init(void)
 {
-    QF_maxPool_ = static_cast<uint_fast8_t>(0);
-    bzero(&QF_timeEvtHead_[0],
-          static_cast<uint_fast16_t>(sizeof(QF_timeEvtHead_)));
-    bzero(&QF_active_[0], static_cast<uint_fast16_t>(sizeof(QF_active_)));
+    QF_priv_.maxPool_ = static_cast<uint_fast8_t>(0);
+    for (uint_fast8_t tickRate = 0U;
+         tickRate < Q_DIM(QTimeEvt_timeEvtHead_);
+         ++tickRate)
+    {
+        QTimeEvt_ctorX(&QTimeEvt_timeEvtHead_[tickRate],
+                       (QActive *)0, Q_USER_SIG, tickRate);
+    }
+
+    bzero(&QActive_registry_[0], static_cast<uint_fast16_t>(sizeof(QActive_registry_)));
 }
 
 extern "C" void QF_stop(void)
 {
     QF_onCleanup();
 }
 
-extern "C" void QActive_start_(QActive * const me, uint_fast8_t prio,
-                    QEvt const * * const qSto, uint_fast16_t const qLen,
-                    void * const stkSto, uint_fast16_t const stkSize,
-                    void const * const par)
+extern "C" void QActive_start_(QActive * const me,
+                               QPrioSpec const prioSpec,
+                               QEvt const * * const qSto,
+                               uint_fast16_t const qLen,
+                               void * const stkSto,
+                               uint_fast16_t const stkSize,
+                               void const * const par)
 {
-    (void)stkSize; /* unused parameter in this port */
+    Q_UNUSED_PAR(stkSto);
+    Q_UNUSED_PAR(stkSize);
 
-    Q_REQUIRE_ID(600, (0U < prio)  /* priority...*/
-                        && (prio <= QF_MAX_ACTIVE) /*... in range */
-                        && (stkSto == (void *)0)); /* stack storage must NOT...
-                                                    * ... be provided */
     QEQueue_init(&me->eQueue, qSto, qLen);
-    me->prio = (uint8_t)prio;
-    QF_add_(me); /* make QF aware of this active object */
+    me->prio  = (uint8_t)(prioSpec & 0xFFU); // QF-priority of the AO
+
+    QActive_register_(me); // register this AO
 
-    /* the top-most initial tran. (virtual) */
-    QHSM_INIT(&me->super, par, me->prio);
+    // top-most initial tran. (virtual call)
+    (*me->super.vptr->init)(&me->super, par, me->prio);
 }
 
-#ifdef QF_ACTIVE_STOP
+#ifdef QACTIVE_CAN_STOP
 extern "C" void QActive_stop(QActive * const me) {
 
     QActive_unsubscribeAll(me); /* unsubscribe from all events */
 
     /* make sure the AO is no longer in "ready set" */
     QPSet_remove(&cpputest_readySet_, me->prio);
 
-    QF_remove_(me); /* remove this AO from QF */
+    QActive_unregister_(me); // un-register this active object
 }
 #endif
 
 extern "C" void QF_runUntilNoReadyActiveObjects()
 {
     while (QPSet_notEmpty(&cpputest_readySet_)) {
         uint_fast8_t p = QPSet_findMax(&cpputest_readySet_);
-        QActive* a     = QF_active_[p];
+        QActive* a     = QActive_registry_[p];
 
         // the active object 'a' must still be registered in QF
         // (e.g., it must not be stopped)
         Q_ASSERT_ID(320, a != nullptr);
 
         while (a->eQueue.frontEvt != nullptr) {
             QEvt const *e = QActive_get_(a);
-            QHSM_DISPATCH(&a->super, e, a->prio);
+            (*a->super.vptr->dispatch)(&a->super, e, a->prio);
             QF_gc(e);
         }