dummy active object: add an event recorder option.

Author: mattheweshleman

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

@@ -30,6 +30,8 @@
 #include <array>
 #include <functional>
 #include <cstdlib>
+#include "cmsVectorBackedQEQueue.hpp"
+#include "qevtUniquePtr.hpp"
 
 namespace cms {
 
@@ -40,17 +42,42 @@ namespace cms {
 template <size_t InternalEventCount>
 class DummyActiveObject  {
 public:
+
+    enum class EventBehavior  {
+        CALLBACK,  //original behavior, will call the provided callback
+        RECORDER   //will record the event
+    };
+
     using PostedEventHandler = std::function<void(QEvt const*)>;
 
-    explicit DummyActiveObject() :
+    DummyActiveObject() :
         m_super(),
         m_eventHandler(nullptr),
-        m_incomingEvents()
+        m_incomingEvents(),
+        m_behavior(EventBehavior::CALLBACK),
+        m_recordedEvents(0)
     {
         m_incomingEvents.fill(nullptr);
         QActive_ctor(&m_super, Q_STATE_CAST(initial));
     }
 
+    explicit DummyActiveObject(EventBehavior behavior) :
+        m_super(),
+        m_eventHandler(nullptr),
+        m_incomingEvents(),
+        m_behavior(behavior),
+        m_recordedEvents(100)
+    {
+        m_incomingEvents.fill(nullptr);
+        QActive_ctor(&m_super, Q_STATE_CAST(initial));
+
+        if (m_behavior == EventBehavior::RECORDER) {
+            m_eventHandler = [=](QEvt const* e) {
+                this->RecorderEventHandler(e);
+            };
+        }
+    }
+
     ~DummyActiveObject()
     {
         QActive_stop(&m_super);
@@ -63,7 +90,9 @@ class DummyActiveObject  {
 
     void SetPostedEventHandler(const PostedEventHandler& handler)
     {
-        m_eventHandler = handler;
+        if (m_behavior == EventBehavior::CALLBACK) {
+            m_eventHandler = handler;
+        }
     }
 
     void dummyStart(uint_fast8_t priority = 1)
@@ -78,6 +107,30 @@ class DummyActiveObject  {
         return &m_super;
     }
 
+    bool isRecorderEmpty() { return m_recordedEvents.isEmpty(); }
+
+    bool isAnyEventRecorded() { return !m_recordedEvents.isEmpty(); }
+
+    bool isSignalRecorded(enum_t sig)
+    {
+        if (!isAnyEventRecorded()) {
+            return false;
+        }
+
+        const auto e       = getRecordedEvent();
+        enum_t recordedSig = e->sig;
+        return recordedSig == sig;
+    }
+
+    cms::QEvtUniquePtr getRecordedEvent()
+    {
+        if (!isAnyEventRecorded()) {
+            return {};
+        }
+
+        return cms::QEvtUniquePtr(m_recordedEvents.get());
+    }
+
 protected:
     static QState initial(DummyActiveObject* const me,
                               QEvt const* const)
@@ -108,10 +161,21 @@ class DummyActiveObject  {
         return rtn;
     }
 
+protected:
+    void RecorderEventHandler(QEvt const * e)
+    {
+        if (e->sig >= Q_USER_SIG) {
+            // record the event
+            m_recordedEvents.post(e, QF_NO_MARGIN);
+        }
+    }
+
 private:
     QActive m_super;
     PostedEventHandler m_eventHandler;
     std::array<QEvt const*, InternalEventCount> m_incomingEvents;
+    EventBehavior m_behavior;
+    cms::VectorBackedQEQueue m_recordedEvents;
 };
 
 using DefaultDummyActiveObject = DummyActiveObject<50>;

cpputest-for-qpc-lib/tests/CMakeLists.txt

@@ -5,6 +5,7 @@ set(TEST_SOURCES
         cms_cpputest_qf_ctrlTests.cpp
         cms_cpputest_qf_ctrlPublishTests.cpp
         cms_cpputest_qf_ctrl_post_tests.cpp
+        cms_dummy_active_object_tests.cpp
         publishedEventRecorderTests.cpp
         backedQueueTests.cpp
         )

cpputest-for-qpc-lib/tests/cms_dummy_active_object_tests.cpp

@@ -0,0 +1,71 @@
+#include "cmsDummyActiveObject.hpp"
+#include "cms_cpputest_qf_ctrl.hpp"
+#include "qpc.h"
+#include <memory>
+
+//cpputest header include must always be last
+#include "CppUTest/TestHarness.h"
+
+using namespace cms;
+using namespace cms::test;
+
+TEST_GROUP(dummy_ao_tests)
+{
+    void setup() final
+    {
+        qf_ctrl::Setup(Q_USER_SIG, 100);
+    }
+
+    void teardown() final
+    {
+        qf_ctrl::Teardown();
+    }
+};
+
+TEST(dummy_ao_tests, dummy_ao_provides_callback_by_default)
+{
+    auto dummy = std::make_unique<DefaultDummyActiveObject>();
+    dummy->dummyStart();
+    CHECK_TRUE(dummy->isRecorderEmpty());
+    CHECK_FALSE(dummy->isAnyEventRecorded());
+
+    static constexpr enum_t TEST1_SIG = Q_USER_SIG + 1;
+    enum_t capturedSig = -1;
+    dummy->SetPostedEventHandler([&](const QEvt* e){
+        capturedSig = e->sig;
+    });
+    qf_ctrl::PostAndProcess<TEST1_SIG>(dummy->getQActive());
+    CHECK_EQUAL(TEST1_SIG, capturedSig);
+    CHECK_FALSE(dummy->isAnyEventRecorded()); //still false, internal recorder not in use here.
+    CHECK_TRUE(dummy->isRecorderEmpty());
+}
+
+TEST(dummy_ao_tests, dummy_ao_provides_recorder_option)
+{
+    auto dummy = std::make_unique<DefaultDummyActiveObject>(DefaultDummyActiveObject::EventBehavior::RECORDER);
+    dummy->dummyStart();
+
+    static constexpr enum_t TEST1_SIG = Q_USER_SIG + 1;
+    static constexpr enum_t TEST2_SIG = TEST1_SIG + 1;
+
+    CHECK_TRUE(dummy->isRecorderEmpty());
+
+    enum_t capturedSig = -1;
+
+    //this should actually do nothing, since this AO is using its internal
+    //recorder
+    dummy->SetPostedEventHandler([&](const QEvt* e){
+        capturedSig = e->sig;
+    });
+    qf_ctrl::PostAndProcess<TEST1_SIG>(dummy->getQActive());
+    qf_ctrl::PostAndProcess<TEST2_SIG>(dummy->getQActive());
+    CHECK_EQUAL(-1, capturedSig); //confirm above callback did NOT happen
+
+    CHECK_TRUE(dummy->isAnyEventRecorded());
+    auto recordedEvent1 = dummy->getRecordedEvent();
+    CHECK_TRUE(recordedEvent1 != nullptr);
+    CHECK_EQUAL(TEST1_SIG, recordedEvent1->sig);
+
+    CHECK_TRUE(dummy->isAnyEventRecorded());
+    CHECK_TRUE(dummy->isSignalRecorded(TEST2_SIG));
+}