feat(dobj/LockableDObject): added thread safe implimentation of DObject

In order to build a preformant code code base we may want to make parallized code in which case having a lockable DObject is a useful construct

tests/dobj/LockableDObjectTest.cpp

@@ -0,0 +1,89 @@
+#include <gtest/gtest.h>
+#include "LockableDObject.h"
+#include <thread>
+#include <vector>
+
+/**
+ * @file LockableDObjectTest.cpp
+ * @brief Unit tests for the LockableDObject class.
+ */
+
+/**
+ * @brief Test suite for the LockableDObject class.
+ */
+class LockableDObjectTest : public ::testing::Test {
+protected:
+    LockableDObject lockableObject;
+
+    void SetUp() override {
+        // Initialize the LockableDObject for tests
+        DObject& obj = lockableObject.get();
+        obj.setData(42); // Set initial data
+    }
+};
+
+/**
+ * @test Verify the default construction of LockableDObject.
+ */
+TEST_F(LockableDObjectTest, DefaultConstruction) {
+    EXPECT_NO_THROW(LockableDObject obj);
+}
+
+/**
+ * @test Verify access to the underlying DObject.
+ */
+TEST_F(LockableDObjectTest, AccessDObject) {
+    DObject& obj = lockableObject.get();
+    EXPECT_EQ(std::get<int>(obj.getData()), 42); // Ensure the data is accessible
+}
+
+/**
+ * @test Verify locking and unlocking.
+ */
+TEST_F(LockableDObjectTest, LockAndUnlock) {
+    EXPECT_NO_THROW(lockableObject.lock());
+    EXPECT_NO_THROW(lockableObject.unlock());
+}
+
+/**
+ * @test Verify thread safety with multiple threads.
+ */
+TEST_F(LockableDObjectTest, ThreadSafety) {
+    const int numThreads = 10;
+    std::vector<std::thread> threads;
+    std::atomic<int> successCount{0};
+
+    // Each thread tries to update the data
+    for (int i = 0; i < numThreads; ++i) {
+        threads.emplace_back([this, i, &successCount]() {
+            lockableObject.lock();
+            DObject& obj = lockableObject.get();
+            obj.setData(i);
+            if (std::get<int>(obj.getData()) == i) {
+                successCount++;
+            }
+            lockableObject.unlock();
+        });
+    }
+
+    for (auto& t : threads) {
+        t.join();
+    }
+
+    EXPECT_EQ(successCount, numThreads);
+}
+
+/**
+ * @test Verify that the DObject remains consistent when accessed via LockableDObject.
+ */
+TEST_F(LockableDObjectTest, ConsistentState) {
+    lockableObject.lock();
+    DObject& obj = lockableObject.get();
+    obj.setData(100);
+    EXPECT_EQ(std::get<int>(obj.getData()), 100);
+    lockableObject.unlock();
+
+    lockableObject.lock();
+    EXPECT_EQ(std::get<int>(lockableObject.get().getData()), 100);
+    lockableObject.unlock();
+}