feat: pure stateguard interface for BLE (#1305)

* pure stateguard interface

* stateguard owner template

* remove StateGuardWithOwner

* graceful func and better reporting

* add unit tests

* Reorder preprocessor directive for clarity

Author: MiquelJayson-Philips

services/ble/CMakeLists.txt

@@ -41,6 +41,7 @@ target_sources(services.ble PRIVATE
     GattServerCharacteristicImpl.hpp
     RetryGattClientCharacteristicsOperations.cpp
     RetryGattClientCharacteristicsOperations.hpp
+    StateGuard.hpp
 )
 
 add_subdirectory(test)

services/ble/StateGuard.hpp

@@ -0,0 +1,55 @@
+#ifndef SERVICES_BLE_STATE_GUARD_HPP
+#define SERVICES_BLE_STATE_GUARD_HPP
+
+#include "infra/stream/StringOutputStream.hpp"
+#include "infra/util/ReallyAssert.hpp"
+#include "services/ble/Gap.hpp"
+#include <algorithm>
+#include <initializer_list>
+
+namespace services
+{
+
+    class StateGuard
+    {
+    public:
+        StateGuard() = default;
+        StateGuard(const StateGuard& other) = delete;
+        StateGuard& operator=(const StateGuard& other) = delete;
+        virtual ~StateGuard() = default;
+
+        bool StateIs(std::initializer_list<GapState> states) const
+        {
+            auto currentState = DetermineCurrentState();
+            return std::any_of(states.begin(), states.end(), [currentState](auto state)
+                {
+                    return state == currentState;
+                });
+        }
+
+        void AssertStateIs(std::initializer_list<GapState> states) const
+        {
+            if (!StateIs(states))
+            {
+                infra::StringOutputStream::WithStorage<16> stream;
+                for (auto it = states.begin(); it != states.end(); ++it)
+                {
+                    if (it != states.begin())
+                        stream << ",";
+                    stream << static_cast<int>(*it);
+                }
+
+                really_assert_with_msg(false,
+                    "Unexpected state found: %d, expected: [%.*s]",
+                    static_cast<int>(DetermineCurrentState()),
+                    static_cast<int>(stream.Storage().size()),
+                    stream.Storage().data());
+            }
+        }
+
+    protected:
+        virtual GapState DetermineCurrentState() const = 0;
+    };
+} // namespace services
+
+#endif // SERVICES_BLE_STATE_GUARD_HPP

services/ble/test/CMakeLists.txt

@@ -22,4 +22,5 @@ target_sources(services.ble_test PRIVATE
     TestGapAdvertisementFormatter.cpp
     TestGattServer.cpp
     TestRetryGattClientAdapter.cpp
+    TestStateGuard.cpp
 )

services/ble/test/TestStateGuard.cpp

@@ -0,0 +1,84 @@
+#include "infra/util/LogAndAbort.hpp"
+#include "services/ble/StateGuard.hpp"
+#include "gmock/gmock.h"
+#include <cstdarg>
+#include <cstdio>
+
+namespace services
+{
+    namespace
+    {
+        class StateGuardMock
+            : public StateGuard
+        {
+        public:
+            MOCK_METHOD(GapState, DetermineCurrentState, (), (const, override));
+        };
+
+        class TestStateGuard
+            : public testing::Test
+        {
+        public:
+            ~TestStateGuard()
+            {
+                infra::RegisterLogAndAbortHook(nullptr);
+            }
+
+            void RegisterStderrHook()
+            {
+                infra::RegisterLogAndAbortHook([]([[maybe_unused]] const char* reason, [[maybe_unused]] const char* file, [[maybe_unused]] int line, const char* format, va_list* args)
+                    {
+                        std::vfprintf(stderr, format, *args);
+                    });
+            }
+
+            testing::NiceMock<StateGuardMock> stateGuard;
+        };
+    }
+
+    TEST_F(TestStateGuard, state_is_returns_true_when_current_state_matches)
+    {
+        ON_CALL(stateGuard, DetermineCurrentState()).WillByDefault(testing::Return(GapState::standby));
+
+        EXPECT_THAT(stateGuard.StateIs({ GapState::standby }), testing::IsTrue());
+    }
+
+    TEST_F(TestStateGuard, state_is_returns_true_when_current_state_matches_one_of_many)
+    {
+        ON_CALL(stateGuard, DetermineCurrentState()).WillByDefault(testing::Return(GapState::connected));
+
+        EXPECT_THAT(stateGuard.StateIs({ GapState::standby, GapState::connected }), testing::IsTrue());
+    }
+
+    TEST_F(TestStateGuard, state_is_returns_false_when_current_state_does_not_match)
+    {
+        ON_CALL(stateGuard, DetermineCurrentState()).WillByDefault(testing::Return(GapState::advertising));
+
+        EXPECT_THAT(stateGuard.StateIs({ GapState::standby, GapState::connected }), testing::IsFalse());
+    }
+
+    TEST_F(TestStateGuard, assert_state_is_does_not_abort_when_state_matches)
+    {
+        ON_CALL(stateGuard, DetermineCurrentState()).WillByDefault(testing::Return(GapState::standby));
+
+        stateGuard.AssertStateIs({ GapState::standby, GapState::connected });
+    }
+
+#ifndef EMIL_MUTATION_TESTING
+    TEST_F(TestStateGuard, assert_state_is_aborts_with_message_for_single_expected_state)
+    {
+        ON_CALL(stateGuard, DetermineCurrentState()).WillByDefault(testing::Return(GapState::advertising));
+        RegisterStderrHook();
+
+        EXPECT_DEATH(stateGuard.AssertStateIs({ GapState::standby }), "Unexpected state found: 3, expected: \\[0\\]");
+    }
+
+    TEST_F(TestStateGuard, assert_state_is_aborts_with_message_for_multiple_expected_states)
+    {
+        ON_CALL(stateGuard, DetermineCurrentState()).WillByDefault(testing::Return(GapState::initiating));
+        RegisterStderrHook();
+
+        EXPECT_DEATH(stateGuard.AssertStateIs({ GapState::standby, GapState::connected }), "Unexpected state found: 4, expected: \\[0,2\\]");
+    }
+#endif
+}