UniqueLock class: "Swap" method now actually swaps ownership of the wrapped mutexes

base_cpp/include/embb/base/internal/mutex-inl.h

@@ -28,6 +28,7 @@
 #define EMBB_BASE_INTERNAL_MUTEX_INL_H_
 #define EMBB_BASE_INTERNAL_MUTEX_INL_H_
 
 
 #include <cassert>
 #include <cassert>
+#include <algorithm>
 
 
 namespace embb {
 namespace embb {
 namespace base {
 namespace base {
@@ -95,8 +96,8 @@ void UniqueLock<Mutex>::Unlock() {
 
 
 template<typename Mutex>
 template<typename Mutex>
 void UniqueLock<Mutex>::Swap(UniqueLock<Mutex>& other) {
 void UniqueLock<Mutex>::Swap(UniqueLock<Mutex>& other) {
-  locked_ = other.locked_;
-  mutex_ = other.Release();
+  std::swap(mutex_, other.mutex_);
+  std::swap(locked_, other.locked_);
 }
 }
 
 
 template<typename Mutex>
 template<typename Mutex>

base_cpp/include/embb/base/mutex.h

@@ -439,11 +439,11 @@ class UniqueLock {
   void Unlock();
   void Unlock();
 
 
   /**
   /**
-   * Transfers ownership of a mutex to this lock.
+   * Exchanges ownership of the wrapped mutexes with another lock.
    */
    */
   void Swap(
   void Swap(
     UniqueLock<Mutex>& other
     UniqueLock<Mutex>& other
-    /**< [IN/OUT] Lock from which ownership shall be transferred */
+    /**< [IN/OUT] The lock to exchange ownership with */
     );
     );
 
 
   /**
   /**

base_cpp/test/mutex_test.cc

@@ -191,13 +191,29 @@ void MutexTest::TestUniqueLock() {
   }
   }
 
 
   { // Test lock swapping
   { // Test lock swapping
-    UniqueLock<> lock1;
+    // Create a second mutex to swap with
+    Mutex another_mutex;
+    UniqueLock<> lock1(another_mutex);
+    PT_EXPECT_EQ(lock1.OwnsLock(), true);
+
+    {
       UniqueLock<> lock2(mutex_);
       UniqueLock<> lock2(mutex_);
-    PT_EXPECT_EQ(lock1.OwnsLock(), false);
       PT_EXPECT_EQ(lock2.OwnsLock(), true);
       PT_EXPECT_EQ(lock2.OwnsLock(), true);
+
       lock1.Swap(lock2);
       lock1.Swap(lock2);
       PT_EXPECT_EQ(lock1.OwnsLock(), true);
       PT_EXPECT_EQ(lock1.OwnsLock(), true);
-    PT_EXPECT_EQ(lock2.OwnsLock(), false);
+      PT_EXPECT_EQ(lock2.OwnsLock(), true);
+    }
+
+    // At this point, lock2 was destroyed and "another_mutex" must be unlocked
+    UniqueLock<> lock3(another_mutex, embb::base::try_lock);
+    PT_EXPECT_EQ(lock3.OwnsLock(), true);
+
+    // But lock1 must still be locking "mutex_"
+    PT_EXPECT_EQ(lock1.OwnsLock(), true);
+
+    lock1.Release()->Unlock();
+    PT_EXPECT_EQ(lock1.OwnsLock(), false);
   }
   }
 }
 }