From d80aeb2ef9548d74bf76e60f8158a8fcea50e6fb Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Mon, 16 Mar 2026 16:35:46 +0100
Subject: [PATCH 1/3] mw/com/impl: adds GetLatestSlot function

- Adds GetLatestSlot function to EventDataControlComposite

Issue: SWP-249517
---
 .../lola/event_data_control_composite.cpp     | 96 +++++++++++++++++++
 .../lola/event_data_control_composite.h       |  4 +
 .../event_data_control_composite_test.cpp     | 67 +++++++++++++
 3 files changed, 167 insertions(+)

diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
index f124db121..618e93fd7 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
@@ -38,6 +38,55 @@ EventDataControlCompositeImpl<AtomicIndirectorType>::EventDataControlCompositeIm
     CheckForValidDataControls();
 }
 
+template <template <class> class AtomicIndirectorType>
+score::cpp::optional<SlotIndexType> EventDataControlCompositeImpl<AtomicIndirectorType>::FindLatestReadableSlotIndex(
+    const EventDataControl& control) const noexcept
+{
+    EventSlotStatus::EventTimeStamp latest_time_stamp{1U};
+    score::cpp::optional<SlotIndexType> latest_slot_index{};
+
+    for (SlotIndexType slot_index = 0U;
+         // Suppress "AUTOSAR C++14 A4-7-1" rule finding. This rule states: "An integer expression shall not lead
+         // to loss.". As the maximum number of slots is std::uint16_t, so there is no case for a data loss here.
+         // coverity[autosar_cpp14_a4_7_1_violation]
+         slot_index < static_cast<SlotIndexType>(control.state_slots_.size());
+         ++slot_index)
+    {
+        SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(static_cast<std::size_t>(slot_index) < control.state_slots_.size());
+        const EventSlotStatus slot{control.state_slots_[slot_index].load(std::memory_order_acquire)};
+        if (!slot.IsInvalid() && !slot.IsInWriting())
+        {
+            const auto slot_time_stamp = slot.GetTimeStamp();
+            if (latest_time_stamp < slot_time_stamp)
+            {
+                latest_time_stamp = slot_time_stamp;
+                latest_slot_index = slot_index;
+            }
+        }
+    }
+
+    return latest_slot_index;
+}
+
+template <template <class> class AtomicIndirectorType>
+bool EventDataControlCompositeImpl<AtomicIndirectorType>::TryIncreaseReferenceCount(
+    ControlSlotType& slot) const noexcept
+{
+    EventSlotStatus slot_old{slot.load(std::memory_order_acquire)};
+    if (slot_old.IsInvalid() || slot_old.IsInWriting())
+    {
+        return false;
+    }
+
+    const auto new_refcount = static_cast<EventSlotStatus::SubscriberCount>(slot_old.GetReferenceCount() + 1U);
+    EventSlotStatus slot_new{slot_old.GetTimeStamp(), new_refcount};
+
+    auto slot_old_value = static_cast<EventSlotStatus::value_type&>(slot_old);
+    auto slot_new_value = static_cast<EventSlotStatus::value_type&>(slot_new);
+    return AtomicIndirectorType<EventSlotStatus::value_type>::compare_exchange_weak(
+        slot, slot_old_value, slot_new_value, std::memory_order_acq_rel);
+}
+
 template <template <class> class AtomicIndirectorType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". This is a false positive, all results which are accessed with '.value()' that could implicitly call
@@ -303,6 +352,53 @@ EventSlotStatus::EventTimeStamp EventDataControlCompositeImpl<AtomicIndirectorTy
     }
 }
 
+template <template <class> class AtomicIndirectorType>
+ControlSlotCompositeIndicator EventDataControlCompositeImpl<AtomicIndirectorType>::GetLatestSlot() const noexcept
+{
+    EventDataControl* control = (asil_b_control_ != nullptr) ? asil_b_control_ : asil_qm_control_;
+
+    for (std::size_t retry_counter{0U}; retry_counter < MAX_MULTI_ALLOCATE_RETRY_COUNT; ++retry_counter)
+    {
+        const auto latest_slot_index = FindLatestReadableSlotIndex(*control);
+
+        if (!latest_slot_index.has_value())
+        {
+            return {};
+        }
+
+        const auto slot_index = latest_slot_index.value();
+
+        if (asil_b_control_ != nullptr)
+        {
+            auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+            auto& slot_asil_b = asil_b_control_->state_slots_[slot_index];
+
+            if (!TryIncreaseReferenceCount(slot_qm))
+            {
+                continue;
+            }
+
+            if (!TryIncreaseReferenceCount(slot_asil_b))
+            {
+                score::cpp::ignore = slot_qm.fetch_sub(1U, std::memory_order_acq_rel);
+                continue;
+            }
+
+            return {slot_index, slot_qm, slot_asil_b};
+        }
+
+        auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+        if (!TryIncreaseReferenceCount(slot_qm))
+        {
+            continue;
+        }
+
+        return {slot_index, slot_qm, ControlSlotCompositeIndicator::CompositeSlotTagType::QM};
+    }
+
+    return {};
+}
+
 template <template <class> class AtomicIndirectorType>
 void EventDataControlCompositeImpl<AtomicIndirectorType>::CheckForValidDataControls() const noexcept
 {
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.h b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
index c052bedf0..5efba2cf1 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.h
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
@@ -98,6 +98,8 @@ class EventDataControlCompositeImpl
     /// \brief Returns the timestamp of the provided slot index
     EventSlotStatus::EventTimeStamp GetEventSlotTimestamp(const SlotIndexType slot) const noexcept;
 
+    ControlSlotCompositeIndicator GetLatestSlot() const noexcept;
+
     EventSlotStatus::EventTimeStamp GetLatestTimestamp() const noexcept;
 
   private:
@@ -110,8 +112,10 @@ class EventDataControlCompositeImpl
 
     // Algorithms that operate on multiple control blocks
     ControlSlotCompositeIndicator GetNextFreeMultiSlot() const noexcept;
+    score::cpp::optional<SlotIndexType> FindLatestReadableSlotIndex(const EventDataControl& control) const noexcept;
 
     bool TryLockSlot(ControlSlotCompositeIndicator slot_indicator) noexcept;
+    bool TryIncreaseReferenceCount(ControlSlotType& slot) const noexcept;
     ControlSlotCompositeIndicator AllocateNextMultiSlot() noexcept;
     void CheckForValidDataControls() const noexcept;
 };
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
index 3f046d58f..7ca576cf3 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
@@ -202,6 +202,73 @@ TEST_F(EventDataControlCompositeFixture, GetLatestTimeStampReturnCorrectValue)
     EXPECT_EQ(time_stamp_obtained, time_stamp);
 }
 
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsLatestReadySlotForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and two ready slots
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto first_slot = unit_->AllocateNextSlot();
+    auto second_slot = unit_->AllocateNextSlot();
+    unit_->EventReady(first_slot, 2U);
+    unit_->EventReady(second_slot, 3U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot with the highest timestamp is returned
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    EXPECT_EQ(latest_slot.GetIndex(), second_slot.GetIndex());
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and one ready slot
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot is referenced once
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    const EventSlotStatus slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    EXPECT_EQ(slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmAndAsilB)
+{
+    // Given an EventDataControlComposite with QM and ASIL-B controls and one ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then both control parts are referenced once
+    ASSERT_TRUE(latest_slot.IsValidQmAndAsilB());
+    const EventSlotStatus qm_slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    const EventSlotStatus asil_b_slot_status{latest_slot.GetSlotAsilB().load(std::memory_order_acquire)};
+    EXPECT_EQ(qm_slot_status.GetReferenceCount(), 1U);
+    EXPECT_EQ(asil_b_slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsInvalidIndicatorIfNoReadableSlotExists)
+{
+    // Given an EventDataControlComposite with no ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then no valid slot is returned
+    EXPECT_FALSE(latest_slot.IsValidQM());
+    EXPECT_FALSE(latest_slot.IsValidAsilB());
+}
+
 TEST_F(EventDataControlCompositeFixture, CanAllocateMultipleSlots)
 {
     // Given an EventDataControlComposite with zero used slots

From 4701854d23949cbbb3059329358bf53b29864567 Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Mon, 16 Mar 2026 17:51:42 +0100
Subject: [PATCH 2/3] mw/com/impl: adds GetLatestSample function

- Adds GetLatestSampleFunction to SkeletonEvent
Issue: SWP-249517
---
 .../com/impl/bindings/lola/skeleton_event.h   | 35 ++++++++++-
 .../bindings/lola/skeleton_event_test.cpp     | 50 ++++++++++++++++
 .../bindings/mock_binding/skeleton_event.h    |  5 ++
 score/mw/com/impl/skeleton_event.h            |  5 ++
 score/mw/com/impl/skeleton_event_binding.h    |  2 +
 .../com/impl/skeleton_event_binding_test.cpp  |  4 ++
 score/mw/com/impl/skeleton_event_test.cpp     | 58 +++++++++++++++++++
 7 files changed, 158 insertions(+), 1 deletion(-)

diff --git a/score/mw/com/impl/bindings/lola/skeleton_event.h b/score/mw/com/impl/bindings/lola/skeleton_event.h
index cb9c035e1..987475bb1 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event.h
+++ b/score/mw/com/impl/bindings/lola/skeleton_event.h
@@ -90,6 +90,8 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
 
     Result<impl::SampleAllocateePtr<SampleType>> Allocate() noexcept override;
 
+    Result<SampleType> GetLatestSample() noexcept override;
+
     /// @requirement SWS_CM_00700
     ResultBlank PrepareOffer() noexcept override;
 
@@ -232,7 +234,7 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
 {
     if (event_data_control_composite_.has_value() == false)
     {
-        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControl does not exist!";
+        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControlComposite does not exist!";
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     const auto slot = event_data_control_composite_->AllocateNextSlot();
@@ -271,6 +273,37 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
     }
 }
 
+template <typename SampleType>
+Result<SampleType> SkeletonEvent<SampleType>::GetLatestSample() noexcept
+{
+    if (event_data_control_composite_.has_value() == false)
+    {
+        ::score::mw::log::LogError("lola") << "Tried to get the latest sample, but the EventDataControlComposite does not exist!";
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+    auto slot = event_data_control_composite_->GetLatestSlot();
+
+    if (slot.IsValidQM() || slot.IsValidAsilB())
+    {
+        const auto sample = event_data_storage_->at(static_cast<std::uint64_t>(slot.GetIndex()));
+
+        if (slot.IsValidQM())
+        {
+            score::cpp::ignore = slot.GetSlotQM().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+        if (slot.IsValidAsilB())
+        {
+            score::cpp::ignore = slot.GetSlotAsilB().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+
+        return sample;
+    }
+    else
+    {
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+}
+
 template <typename SampleType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". This is a false positive, all results which are accessed with '.value()' that could implicitly call
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
index 8827bfa08..e07306e15 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
+++ b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
@@ -318,6 +318,56 @@ TEST_F(SkeletonEventPrepareStopOfferFixture, StopOfferSkeletonEvent)
     skeleton_event_->PrepareStopOffer();
 }
 
+using SkeletonEventGetLatestSampleFixture = SkeletonEventFixture;
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsBeforePrepareOffer)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsIfNoSampleWasSent)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleReturnsMostRecentlySentSample)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    auto first_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(first_allocated_slot_result.has_value());
+    auto first_allocated_slot = std::move(first_allocated_slot_result).value();
+    *first_allocated_slot = static_cast<test::TestSampleType>(11U);
+    auto first_send_result = skeleton_event_->Send(std::move(first_allocated_slot), score::cpp::nullopt);
+    ASSERT_TRUE(first_send_result.has_value());
+
+    auto second_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(second_allocated_slot_result.has_value());
+    auto second_allocated_slot = std::move(second_allocated_slot_result).value();
+    *second_allocated_slot = static_cast<test::TestSampleType>(42U);
+    auto second_send_result = skeleton_event_->Send(std::move(second_allocated_slot), score::cpp::nullopt);
+    ASSERT_TRUE(second_send_result.has_value());
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_TRUE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.value(), static_cast<test::TestSampleType>(42U));
+}
+
 using SkeletonEventTimestampFixture = SkeletonEventFixture;
 TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
 {
diff --git a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
index 7bf6e5e74..8c7057324 100644
--- a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
+++ b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
@@ -47,6 +47,7 @@ class SkeletonEvent : public SkeletonEventBinding<SampleType>
                  score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(Result<SampleAllocateePtr<SampleType>>, Allocate, (), (noexcept, override));
+    MOCK_METHOD(Result<SampleType>, GetLatestSample, (), (noexcept, override));
     MOCK_METHOD(ResultBlank, PrepareOffer, (), (noexcept, override));
     MOCK_METHOD(void, PrepareStopOffer, (), (noexcept, override));
     MOCK_METHOD(std::size_t, GetMaxSize, (), (const, noexcept, override));
@@ -82,6 +83,10 @@ class SkeletonEventFacade : public SkeletonEventBinding<SampleType>
     {
         return skeleton_event_.Allocate();
     };
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return skeleton_event_.GetLatestSample();
+    }
     ResultBlank PrepareOffer() noexcept override
     {
         return skeleton_event_.PrepareOffer();
diff --git a/score/mw/com/impl/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index bca539e77..ff1ceec9e 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -312,6 +312,11 @@ class SkeletonEventView
         return skeleton_event_.GetTypedEventBinding();
     }
 
+    Result<SampleType> GetLatestSample() noexcept
+    {
+        return GetBinding()->GetLatestSample();
+    }
+
   private:
     SkeletonEvent<SampleType>& skeleton_event_;
 };
diff --git a/score/mw/com/impl/skeleton_event_binding.h b/score/mw/com/impl/skeleton_event_binding.h
index 7255ab8f1..198f7d153 100644
--- a/score/mw/com/impl/skeleton_event_binding.h
+++ b/score/mw/com/impl/skeleton_event_binding.h
@@ -89,6 +89,8 @@ class SkeletonEventBinding : public SkeletonEventBindingBase
     /// implementations.
     virtual Result<SampleAllocateePtr<SampleType>> Allocate() noexcept = 0;
 
+    virtual Result<SampleType> GetLatestSample() noexcept = 0;
+
     std::size_t GetMaxSize() const noexcept override
     {
         return sizeof(SampleType);
diff --git a/score/mw/com/impl/skeleton_event_binding_test.cpp b/score/mw/com/impl/skeleton_event_binding_test.cpp
index a60a5c7ac..9edc6e46c 100644
--- a/score/mw/com/impl/skeleton_event_binding_test.cpp
+++ b/score/mw/com/impl/skeleton_event_binding_test.cpp
@@ -46,6 +46,10 @@ class MyEvent final : public SkeletonEventBinding<SampleType>
     {
         return MakeSampleAllocateePtr(std::make_unique<SampleType>());
     }
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return SampleType{};
+    }
     BindingType GetBindingType() const noexcept override
     {
         return BindingType::kFake;
diff --git a/score/mw/com/impl/skeleton_event_test.cpp b/score/mw/com/impl/skeleton_event_test.cpp
index 1db0646b6..af4afdff1 100644
--- a/score/mw/com/impl/skeleton_event_test.cpp
+++ b/score/mw/com/impl/skeleton_event_test.cpp
@@ -653,5 +653,63 @@ TEST(SkeletonEventTest, MovingAssigningSkeletonUpdatesEventMapReference)
     EXPECT_EQ(&event, &unit2.my_dummy_event_);
 }
 
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleDispatchesToBinding)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+
+    // and that GetLatestSample() is called once on the event binding which returns a valid sample
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
+        .WillOnce(Return(ByMove(static_cast<TestSampleType>(42U))));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result = SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample();
+
+    // Then the result is valid and contains the sample from the binding
+    ASSERT_TRUE(latest_sample_result.has_value());
+    EXPECT_EQ(latest_sample_result.value(), static_cast<TestSampleType>(42U));
+}
+
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleWhenBindingFailsReturnsError)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+
+    // and that GetLatestSample() is called once on the event binding which returns an error
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
+        .WillOnce(Return(ByMove(MakeUnexpected(ComErrc::kBindingFailure))));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result = SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample();
+
+    // Then the result contains an error that the binding failed
+    ASSERT_FALSE(latest_sample_result.has_value());
+    EXPECT_EQ(latest_sample_result.error(), ComErrc::kBindingFailure);
+}
+
 }  // namespace
 }  // namespace score::mw::com::impl

From 2e355eeb35e00963cd0cb3bcfc84f3fb4361349e Mon Sep 17 00:00:00 2001
From: muhseth <muhammad-wahaj.sethi@bmw.de>
Date: Tue, 17 Mar 2026 12:48:52 +0100
Subject: [PATCH 3/3] mw/com/impl: fixes clang format

- fixes clang format issues.
Issue: SWP-249517
---
 .../mw/com/impl/bindings/lola/skeleton_event.h  | 17 +++++++++++------
 .../impl/bindings/mock_binding/skeleton_event.h |  3 ++-
 score/mw/com/impl/skeleton_event.h              | 11 ++++++-----
 .../mw/com/impl/skeleton_event_binding_test.cpp | 10 ++++++----
 score/mw/com/impl/skeleton_event_test.cpp       |  2 --
 5 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/score/mw/com/impl/bindings/lola/skeleton_event.h b/score/mw/com/impl/bindings/lola/skeleton_event.h
index 987475bb1..63869aafa 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event.h
+++ b/score/mw/com/impl/bindings/lola/skeleton_event.h
@@ -83,7 +83,8 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
 
     /// \brief Sends a value by _copy_ towards a consumer. It will allocate the necessary space and then copy the value
     /// into Shared Memory.
-    ResultBlank Send(const SampleType& value, score::cpp::optional<SendTraceCallback> send_trace_callback) noexcept override;
+    ResultBlank Send(const SampleType& value,
+                     score::cpp::optional<SendTraceCallback> send_trace_callback) noexcept override;
 
     ResultBlank Send(impl::SampleAllocateePtr<SampleType> sample,
                      score::cpp::optional<SendTraceCallback> send_trace_callback) noexcept override;
@@ -234,7 +235,8 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
 {
     if (event_data_control_composite_.has_value() == false)
     {
-        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControlComposite does not exist!";
+        ::score::mw::log::LogError("lola")
+            << "Tried to allocate event, but the EventDataControlComposite does not exist!";
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     const auto slot = event_data_control_composite_->AllocateNextSlot();
@@ -278,7 +280,8 @@ Result<SampleType> SkeletonEvent<SampleType>::GetLatestSample() noexcept
 {
     if (event_data_control_composite_.has_value() == false)
     {
-        ::score::mw::log::LogError("lola") << "Tried to get the latest sample, but the EventDataControlComposite does not exist!";
+        ::score::mw::log::LogError("lola")
+            << "Tried to get the latest sample, but the EventDataControlComposite does not exist!";
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     auto slot = event_data_control_composite_->GetLatestSlot();
@@ -316,8 +319,9 @@ ResultBlank SkeletonEvent<SampleType>::PrepareOffer() noexcept
     std::tie(event_data_storage_, event_data_control_composite_) =
         parent_.Register<SampleType>(event_fqn_, event_properties_);
 
-    SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(event_data_control_composite_.has_value(),
-                           "Defensive programming as event_data_control_composite_ is set by Register above.");
+    SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(
+        event_data_control_composite_.has_value(),
+        "Defensive programming as event_data_control_composite_ is set by Register above.");
     current_timestamp_ = event_data_control_composite_.value().GetLatestTimestamp();
 
     const bool tracing_for_skeleton_event_enabled =
@@ -331,7 +335,8 @@ ResultBlank SkeletonEvent<SampleType>::PrepareOffer() noexcept
         // LCOV_EXCL_BR_STOP
         score::cpp::ignore = transaction_log_registration_guard_.emplace(
             TransactionLogRegistrationGuard::Create(event_data_control_composite_->GetQmEventDataControl()));
-        score::cpp::ignore = type_erased_sample_ptrs_guard_.emplace(skeleton_event_tracing_data_.service_element_tracing_data);
+        score::cpp::ignore =
+            type_erased_sample_ptrs_guard_.emplace(skeleton_event_tracing_data_.service_element_tracing_data);
     }
 
     // Register callbacks to be notified when event notification existence changes.
diff --git a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
index 8c7057324..b6f089a74 100644
--- a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
+++ b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
@@ -39,7 +39,8 @@ class SkeletonEvent : public SkeletonEventBinding<SampleType>
   public:
     MOCK_METHOD(ResultBlank,
                 Send,
-                (const SampleType& value, score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
+                (const SampleType& value,
+                 score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(ResultBlank,
                 Send,
diff --git a/score/mw/com/impl/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index ff1ceec9e..722b9fc1f 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -24,8 +24,8 @@
 
 #include "score/mw/com/impl/mocking/i_skeleton_event.h"
 
-#include "score/result/result.h"
 #include "score/mw/log/logging.h"
+#include "score/result/result.h"
 
 #include <memory>
 #include <string_view>
@@ -234,7 +234,7 @@ ResultBlank SkeletonEvent<SampleDataType>::Send(const EventType& sample_value) n
     if (!send_result.has_value())
     {
         score::mw::log::LogError("lola") << "SkeletonEvent::Send with copy failed: " << send_result.error().Message()
-                                       << ": " << send_result.error().UserMessage();
+                                         << ": " << send_result.error().UserMessage();
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     return send_result;
@@ -262,7 +262,7 @@ ResultBlank SkeletonEvent<SampleDataType>::Send(SampleAllocateePtr<EventType> sa
     if (!send_result.has_value())
     {
         score::mw::log::LogError("lola") << "SkeletonEvent::Send zero copy failed: " << send_result.error().Message()
-                                       << ": " << send_result.error().UserMessage();
+                                         << ": " << send_result.error().UserMessage();
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     return send_result;
@@ -287,7 +287,7 @@ Result<SampleAllocateePtr<SampleDataType>> SkeletonEvent<SampleDataType>::Alloca
     if (!allocate_result.has_value())
     {
         score::mw::log::LogError("lola") << "SkeletonEvent::Allocate failed: " << allocate_result.error().Message()
-                                       << ": " << allocate_result.error().UserMessage();
+                                         << ": " << allocate_result.error().UserMessage();
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     return allocate_result;
@@ -297,7 +297,8 @@ template <typename SampleDataType>
 auto SkeletonEvent<SampleDataType>::GetTypedEventBinding() const noexcept -> SkeletonEventBinding<SampleDataType>*
 {
     auto* const typed_binding = dynamic_cast<SkeletonEventBinding<EventType>*>(binding_.get());
-    SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(typed_binding != nullptr, "Downcast to SkeletonEventBinding<EventType> failed!");
+    SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD_MESSAGE(typed_binding != nullptr,
+                                                "Downcast to SkeletonEventBinding<EventType> failed!");
     return typed_binding;
 }
 
diff --git a/score/mw/com/impl/skeleton_event_binding_test.cpp b/score/mw/com/impl/skeleton_event_binding_test.cpp
index 9edc6e46c..5e0461eac 100644
--- a/score/mw/com/impl/skeleton_event_binding_test.cpp
+++ b/score/mw/com/impl/skeleton_event_binding_test.cpp
@@ -32,13 +32,15 @@ class MyEvent final : public SkeletonEventBinding<SampleType>
         return {};
     }
     void PrepareStopOffer() noexcept override {}
-    ResultBlank Send(const SampleType&,
-                     score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
+    ResultBlank Send(
+        const SampleType&,
+        score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
     {
         return {};
     }
-    ResultBlank Send(SampleAllocateePtr<SampleType>,
-                     score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
+    ResultBlank Send(
+        SampleAllocateePtr<SampleType>,
+        score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>) noexcept override
     {
         return {};
     }
diff --git a/score/mw/com/impl/skeleton_event_test.cpp b/score/mw/com/impl/skeleton_event_test.cpp
index af4afdff1..9bde6ac75 100644
--- a/score/mw/com/impl/skeleton_event_test.cpp
+++ b/score/mw/com/impl/skeleton_event_test.cpp
@@ -666,7 +666,6 @@ TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleDispatchesToBinding
                 Create(kInstanceIdWithLolaBinding, _, kEventName))
         .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
 
-
     // and that GetLatestSample() is called once on the event binding which returns a valid sample
     EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
         .WillOnce(Return(ByMove(static_cast<TestSampleType>(42U))));
@@ -695,7 +694,6 @@ TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleWhenBindingFailsRet
                 Create(kInstanceIdWithLolaBinding, _, kEventName))
         .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
 
-
     // and that GetLatestSample() is called once on the event binding which returns an error
     EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
         .WillOnce(Return(ByMove(MakeUnexpected(ComErrc::kBindingFailure))));