A first test, and some fixes

arangodb · mchacki · Jul 12, 2021 · Jul 9, 2019 · Jul 18, 2019 · Oct 9, 2019
commit 86ff2c1b26e3b614b08a731422b8b82be2758800
diff --git a/lib/Utilities/Guarded.h b/lib/Utilities/Guarded.h
@@ -35,7 +35,7 @@ class Mutex;
 template <class T, class M = Mutex>
 class MutexGuard {
  public:
-  explicit MutexGuard(T& value, M mutex);
+  explicit MutexGuard(T& value, M& mutex);
   ~MutexGuard();
 
   T& get() noexcept;
@@ -47,7 +47,7 @@ class MutexGuard {
 };
 
 template <class T, class M>
-MutexGuard<T, M>::MutexGuard(T& value, M mutex) : _value(value), _mutex(mutex) {
+MutexGuard<T, M>::MutexGuard(T& value, M& mutex) : _value(value), _mutex(mutex) {
   _mutex.lock();
 }
 
@@ -69,14 +69,18 @@ T const& MutexGuard<T, M>::get() const noexcept {
 template <class T, class M = Mutex>
 class Guarded {
  public:
-  explicit Guarded(T&& value = T(), M&& mutex = M());
-  explicit Guarded(T value = T(), M mutex = M());
+  explicit Guarded(T&& value = T());
+  template <typename... Args>
+  explicit Guarded(Args...);
 
   // TODO with C++17, these could be noexcept depending on callback being noexcept
   template <class F>
-  decltype(F()) doUnderLock(F callback);
+  std::result_of_t<F(T&)> doUnderLock(F callback);
   template <class F>
-  decltype(F(false)) tryUnderLock(F callback);
+  std::result_of_t<F(T const&)> doUnderLock(F callback);
+
+  // template <class F>
+  // decltype(F(false)) tryUnderLock(F callback);
   // TODO add more types of "do under lock"?
 
   MutexGuard<T, M> getLockedGuard();
@@ -88,31 +92,39 @@ class Guarded {
 };
 
 template <class T, class M>
-Guarded<T, M>::Guarded(T&& value, M&& mutex)
-    : _value(std::forward<T>(value)), _mutex(std::forward<T>(mutex)) {}
+Guarded<T, M>::Guarded(T&& value) : _value{std::move(value)}, _mutex{} {}
 
 template <class T, class M>
-Guarded<T, M>::Guarded(T value, M mutex)
-    : _value(std::move(value)), _mutex(std::move(mutex)) {}
+template <typename... Args>
+Guarded<T, M>::Guarded(Args... args) : _value{args...}, _mutex{} {}
 
 template <class T, class M>
 template <class F>
-decltype(F()) Guarded<T, M>::doUnderLock(F callback) {
+std::result_of_t<F(T&)> Guarded<T, M>::doUnderLock(F callback) {
   MUTEX_LOCKER(guard, _mutex);
 
-  return callback();
+  return callback(_value);
 }
 
 template <class T, class M>
 template <class F>
-decltype(F(false)) Guarded<T, M>::tryUnderLock(F callback) {
-  TRY_MUTEX_LOCKER(guard, _mutex);
+std::result_of_t<F(T const&)> Guarded<T, M>::doUnderLock(F callback) {
+  MUTEX_LOCKER(guard, _mutex);
 
-  return callback(guard.isLocked());
+  return callback(_value);
 }
+
+// template <class T, class M>
+// template <class F>
+// decltype(F(false)) Guarded<T, M>::tryUnderLock(F callback) {
+//   TRY_MUTEX_LOCKER(guard, _mutex);
+//
+//   return callback(guard.isLocked());
+// }
+
 template <class T, class M>
-MutexGuard Guarded<T, M>::getLockedGuard() {
-  return MutexGuard(_value, _mutex);
+MutexGuard<T, M> Guarded<T, M>::getLockedGuard() {
+  return MutexGuard<T, M>(_value, _mutex);
 }
 
 }  // namespace arangodb

diff --git a/tests/Basics/GuardedTest.cpp b/tests/Basics/GuardedTest.cpp
@@ -22,8 +22,52 @@
 
 #include "gtest/gtest.h"
 
-#include <lib/Utilities/Guarded.h>
+#include "Utilities/Guarded.h"
+#include "Basics/Mutex.h"
 
-TEST(GuardedTest, basics) {
+#include <mutex>
 
+using namespace arangodb;
+
+namespace arangodb {
+namespace tests {
+
+template <typename Mutex>
+class GuardedTest : public ::testing::Test {
+};
+
+TYPED_TEST_CASE_P(GuardedTest);
+
+TYPED_TEST_P(GuardedTest, test_allows_access) {
+  struct UnderGuard {
+    int val{};
+  };
+  Guarded<UnderGuard, Mutex> guardedObj{UnderGuard{.val = 1}};
+  {
+    MutexGuard<UnderGuard, Mutex> guard = guardedObj.getLockedGuard();
+    EXPECT_EQ(1, guard.get().val);
+    guard.get().val = 2;
+    EXPECT_EQ(2, guard.get().val);
+  }
+  guardedObj.doUnderLock([](UnderGuard& obj) {
+    EXPECT_EQ(2, obj.val);
+    obj.val = 3;
+    EXPECT_EQ(3, obj.val);
+  });
+  // guardedObj.tryUnderLock([](UnderGuard& obj) { ... });
+  {
+    MutexGuard<UnderGuard, Mutex> guard = guardedObj.getLockedGuard();
+    EXPECT_EQ(3, guard.get().val);
+  }
 }
+
+TYPED_TEST_P(GuardedTest, test_2) {}
+
+REGISTER_TYPED_TEST_CASE_P(GuardedTest, test_allows_access, test_2);
+
+using TestedMutexes = ::testing::Types<std::mutex, arangodb::Mutex>;
+
+INSTANTIATE_TYPED_TEST_CASE_P(GuardedTestInstantiation, GuardedTest, TestedMutexes);
+
+}  // namespace tests
+}  // namespace arangodb