LockTraitsTest.cpp File Reference

#include <folly/LockTraits.h>
#include <folly/LockTraitsBoost.h>
#include <mutex>
#include <folly/SharedMutex.h>
#include <folly/SpinLock.h>
#include <folly/portability/GTest.h>
#include <folly/synchronization/RWSpinLock.h>

Go to the source code of this file.

Classes
class	FakeAllPowerfulAssertingMutex

Functions
	TEST (LockTraits, std_mutex)
	TEST (LockTraits, SharedMutex)
	TEST (LockTraits, SpinLock)
	TEST (LockTraits, RWSpinLock)
	TEST (LockTraits, boost_mutex)
	TEST (LockTraits, boost_recursive_mutex)
	TEST (LockTraits, LockPolicy)
	TEST (LockTraits, LockPolicyTimed)
	TEST (LockTraits, LockPolicyCompatibilities)

Variables
static constexpr auto	one_ms = std::chrono::milliseconds(1)

Function Documentation

TEST	(	LockTraits	,
		std_mutex
	)

Definition at line 107 of file LockTraitsTest.cpp.

References folly::detail::lock(), and mutex.

                            {
  using traits = LockTraits<std::mutex>;
  static_assert(!traits::is_timed, "std:mutex is not a timed lock");
  static_assert(!traits::is_shared, "std:mutex is not a shared lock");
  static_assert(!traits::is_upgrade, "std::mutex is not an upgradable lock");

  std::mutex mutex;
  traits::lock(mutex);
  traits::unlock(mutex);
}

TEST	(	LockTraits	,
		SharedMutex
	)

Definition at line 118 of file LockTraitsTest.cpp.

References EXPECT_FALSE, folly::detail::lock(), mutex, and one_ms.

                              {
  using traits = LockTraits<SharedMutex>;
  static_assert(traits::is_timed, "folly::SharedMutex is a timed lock");
  static_assert(traits::is_shared, "folly::SharedMutex is a shared lock");
  static_assert(traits::is_upgrade, "folly::SharedMutex is an upgradable lock");

  SharedMutex mutex;
  traits::lock(mutex);
  traits::unlock(mutex);

  traits::lock_shared(mutex);
  traits::lock_shared(mutex);
  traits::unlock_shared(mutex);
  traits::unlock_shared(mutex);

  traits::lock_upgrade(mutex);
  traits::unlock_upgrade(mutex);

  // test upgrade and downgrades
  traits::lock_upgrade(mutex);
  traits::unlock_upgrade_and_lock(mutex);
  bool gotLock = traits::try_lock_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire an exclusive "
                           "lock after upgrading to an exclusive lock";
  gotLock = traits::try_lock_upgrade_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire an upgrade "
                           "lock after upgrading to an exclusive lock";
  gotLock = traits::try_lock_shared_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire a shared "
                           "lock after upgrading to an exclusive lock";
  traits::unlock(mutex);

  traits::lock_upgrade(mutex);
  traits::unlock_upgrade_and_lock_shared(mutex);
  gotLock = traits::try_lock_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire an exclusive "
                           "mutex after downgrading from an upgrade to a "
                           "shared lock";
  traits::unlock_shared(mutex);

  traits::lock(mutex);
  gotLock = traits::try_lock_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire an exclusive "
                           "lock after acquiring an exclusive lock";
  gotLock = traits::try_lock_upgrade_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire an upgrade "
                           "lock after acquiring an exclusive lock";
  gotLock = traits::try_lock_shared_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire a shared "
                           "lock after acquiring an exclusive lock";
  traits::unlock_and_lock_upgrade(mutex);
  gotLock = traits::try_lock_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire an exclusive "
                           "lock after downgrading to an upgrade lock";
  traits::unlock_upgrade(mutex);

  traits::lock(mutex);
  traits::unlock_and_lock_shared(mutex);
  gotLock = traits::try_lock_for(mutex, one_ms);
  EXPECT_FALSE(gotLock) << "Should not have been able to acquire an exclusive "
                           "lock after downgrading to a shared lock";
  traits::unlock_shared(mutex);
}

TEST	(	LockTraits	,
		SpinLock
	)

Definition at line 182 of file LockTraitsTest.cpp.

References folly::detail::lock(), and mutex.

                           {
  using traits = LockTraits<SpinLock>;
  static_assert(!traits::is_timed, "folly::SpinLock is not a timed lock");
  static_assert(!traits::is_shared, "folly::SpinLock is not a shared lock");
  static_assert(
      !traits::is_upgrade, "folly::SpinLock is not an upgradable lock");

  SpinLock mutex;
  traits::lock(mutex);
  traits::unlock(mutex);
}

TEST	(	LockTraits	,
		RWSpinLock
	)

Definition at line 194 of file LockTraitsTest.cpp.

References folly::detail::lock(), and mutex.

                             {
  using traits = LockTraits<RWSpinLock>;
  static_assert(!traits::is_timed, "folly::RWSpinLock is not a timed lock");
  static_assert(traits::is_shared, "folly::RWSpinLock is a shared lock");
  static_assert(traits::is_upgrade, "folly::RWSpinLock is an upgradable lock");

  RWSpinLock mutex;
  traits::lock(mutex);
  traits::unlock(mutex);

  traits::lock_shared(mutex);
  traits::lock_shared(mutex);
  traits::unlock_shared(mutex);
  traits::unlock_shared(mutex);
}

TEST	(	LockTraits	,
		boost_mutex
	)

Definition at line 210 of file LockTraitsTest.cpp.

References folly::detail::lock(), and mutex.

                              {
  using traits = LockTraits<boost::mutex>;
  static_assert(!traits::is_timed, "boost::mutex is not a timed lock");
  static_assert(!traits::is_shared, "boost::mutex is not a shared lock");
  static_assert(!traits::is_upgrade, "boost::mutex is not an upgradable lock");

  boost::mutex mutex;
  traits::lock(mutex);
  traits::unlock(mutex);
}

TEST	(	LockTraits	,
		boost_recursive_mutex
	)

Definition at line 221 of file LockTraitsTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, folly::detail::lock(), mutex, and folly::TEST().

                                        {
  using traits = LockTraits<boost::recursive_mutex>;
  static_assert(
      !traits::is_timed, "boost::recursive_mutex is not a timed lock");
  static_assert(
      !traits::is_shared, "boost::recursive_mutex is not a shared lock");
  static_assert(
      !traits::is_upgrade, "boost::recursive_mutex is not an upgradable lock");

  boost::recursive_mutex mutex;
  traits::lock(mutex);
  traits::lock(mutex);
  traits::unlock(mutex);
  traits::unlock(mutex);
}

TEST	(	LockTraits	,
		LockPolicy
	)

Chain the asserts from the previous test to the next lock, unlock or upgrade method calls. Each making sure that the previous was correct.

Definition at line 304 of file LockTraitsTest.cpp.

References EXPECT_EQ, folly::LockPolicyUpgrade::lock(), folly::LockPolicyFromUpgradeToExclusive::lock(), folly::LockPolicyFromExclusiveToUpgrade::lock(), folly::LockPolicyFromUpgradeToShared::lock(), folly::LockPolicyFromExclusiveToShared::lock(), mutex, Mutex, folly::detail::UnlockPolicyExclusive< LockTraits >::unlock(), folly::detail::UnlockPolicyShared< LockTraits >::unlock(), and folly::detail::UnlockPolicyUpgrade< LockTraits >::unlock().

                             {
  using Mutex = FakeAllPowerfulAssertingMutex;
  Mutex mutex;

  // test the lock and unlock functions
  LockPolicyUpgrade::lock(mutex);
  mutex.unlock_upgrade();
  mutex.lock_upgrade();
  LockPolicyUpgrade::unlock(mutex);

  mutex.lock_upgrade();
  LockPolicyFromUpgradeToExclusive::lock(mutex);
  mutex.unlock();
  mutex.lock();
  LockPolicyFromUpgradeToExclusive::unlock(mutex);

  mutex.lock();
  LockPolicyFromExclusiveToUpgrade::lock(mutex);
  mutex.unlock_upgrade();
  mutex.lock_upgrade();
  LockPolicyFromExclusiveToUpgrade::unlock(mutex);

  mutex.lock_upgrade();
  LockPolicyFromUpgradeToShared::lock(mutex);
  mutex.unlock_shared();
  mutex.lock_shared();
  LockPolicyFromUpgradeToShared::unlock(mutex);

  mutex.lock();
  LockPolicyFromExclusiveToShared::lock(mutex);
  mutex.unlock_shared();
  mutex.lock_shared();
  LockPolicyFromExclusiveToShared::unlock(mutex);

  EXPECT_EQ(mutex.lock_state, Mutex::CurrentLockState::UNLOCKED);
}

TEST	(	LockTraits	,
		LockPolicyTimed
	)

Similar to the test above but tests the timed version of the updates

Definition at line 344 of file LockTraitsTest.cpp.

References EXPECT_TRUE, mutex, Mutex, one_ms, folly::LockPolicyUpgrade::try_lock_for(), folly::LockPolicyFromUpgradeToExclusive::try_lock_for(), folly::LockPolicyFromExclusiveToUpgrade::try_lock_for(), folly::LockPolicyFromUpgradeToShared::try_lock_for(), folly::LockPolicyFromExclusiveToShared::try_lock_for(), and folly::detail::UnlockPolicyUpgrade< LockTraits >::unlock().

                                  {
  using Mutex = FakeAllPowerfulAssertingMutex;
  Mutex mutex;

  bool gotLock = LockPolicyUpgrade::try_lock_for(mutex, one_ms);
  EXPECT_TRUE(gotLock) << "Should have been able to acquire the fake mutex";
  LockPolicyUpgrade::unlock(mutex);

  mutex.lock_upgrade();
  gotLock = LockPolicyFromUpgradeToExclusive::try_lock_for(mutex, one_ms);
  EXPECT_TRUE(gotLock)
      << "Should have been able to upgrade from upgrade to unique";
  mutex.unlock();

  mutex.lock();
  gotLock = LockPolicyFromExclusiveToUpgrade::try_lock_for(mutex, one_ms);
  EXPECT_TRUE(gotLock) << "Should have been able to downgrade from exclusive "
                          "to upgrade";
  mutex.unlock_upgrade();

  mutex.lock_upgrade();
  gotLock = LockPolicyFromUpgradeToShared::try_lock_for(mutex, one_ms);
  EXPECT_TRUE(gotLock) << "Should have been able to downgrade from upgrade to "
                          "shared";
  mutex.unlock_shared();

  mutex.lock();
  gotLock = LockPolicyFromExclusiveToShared::try_lock_for(mutex, one_ms);
  EXPECT_TRUE(gotLock) << "Should have been able to downgrade from exclusive "
                          "to shared";
  mutex.unlock_shared();
}

TEST	(	LockTraits	,
		LockPolicyCompatibilities
	)

Test compatibility of the different lock policies

This should be correct because the compatibilities here are used to determine whether or not the different LockedPtr instances can be moved from each other

Definition at line 384 of file LockTraitsTest.cpp.

References EXPECT_TRUE, and folly::value().

                                            {
  EXPECT_TRUE((std::is_same<
               LockPolicyExclusive::UnlockPolicy,
               LockPolicyTryExclusive::UnlockPolicy>::value));
  EXPECT_TRUE((std::is_same<
               LockPolicyExclusive::UnlockPolicy,
               LockPolicyFromUpgradeToExclusive::UnlockPolicy>::value));

  EXPECT_TRUE((std::is_same<
               LockPolicyShared::UnlockPolicy,
               LockPolicyTryShared::UnlockPolicy>::value));
  EXPECT_TRUE((std::is_same<
               LockPolicyShared::UnlockPolicy,
               LockPolicyFromUpgradeToShared::UnlockPolicy>::value));
  EXPECT_TRUE((std::is_same<
               LockPolicyShared::UnlockPolicy,
               LockPolicyFromExclusiveToShared::UnlockPolicy>::value));

  EXPECT_TRUE((std::is_same<
               LockPolicyUpgrade::UnlockPolicy,
               LockPolicyTryUpgrade::UnlockPolicy>::value));
  EXPECT_TRUE((std::is_same<
               LockPolicyUpgrade::UnlockPolicy,
               LockPolicyFromExclusiveToUpgrade::UnlockPolicy>::value));
}

Variable Documentation

constexpr auto one_ms = std::chrono::milliseconds(1)

static

Definition at line 28 of file LockTraitsTest.cpp.

Referenced by TEST().