Line data    Source code

       1             : // Copyright (c) 2015 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #include "reverselock.h"
       6             : #include "test/test_bitcoin.h"
       7             : 
       8             : #include <boost/test/unit_test.hpp>
       9             : 
      10           1 : BOOST_FIXTURE_TEST_SUITE(reverselock_tests, BasicTestingSetup)
      11             : 
      12           6 : BOOST_AUTO_TEST_CASE(reverselock_basics)
      13             : {
      14           1 :     boost::mutex mutex;
      15             :     boost::unique_lock<boost::mutex> lock(mutex);
      16             : 
      17           8 :     BOOST_CHECK(lock.owns_lock());
      18             :     {
      19             :         reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
      20           8 :         BOOST_CHECK(!lock.owns_lock());
      21             :     }
      22           9 :     BOOST_CHECK(lock.owns_lock());
      23           1 : }
      24             : 
      25           6 : BOOST_AUTO_TEST_CASE(reverselock_errors)
      26             : {
      27           1 :     boost::mutex mutex;
      28             :     boost::unique_lock<boost::mutex> lock(mutex);
      29             : 
      30             :     // Make sure trying to reverse lock an unlocked lock fails
      31           1 :     lock.unlock();
      32             : 
      33           8 :     BOOST_CHECK(!lock.owns_lock());
      34             : 
      35           1 :     bool failed = false;
      36             :     try {
      37             :         reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
      38           2 :     } catch(...) {
      39           1 :         failed = true;
      40             :     }
      41             : 
      42           7 :     BOOST_CHECK(failed);
      43           8 :     BOOST_CHECK(!lock.owns_lock());
      44             : 
      45             :     // Make sure trying to lock a lock after it has been reverse locked fails
      46           1 :     failed = false;
      47           1 :     bool locked = false;
      48             : 
      49           1 :     lock.lock();
      50           8 :     BOOST_CHECK(lock.owns_lock());
      51             : 
      52             :     try {
      53             :         reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
      54           1 :         lock.lock();
      55           1 :         locked = true;
      56           2 :     } catch(...) {
      57           1 :         failed = true;
      58             :     }
      59             : 
      60           8 :     BOOST_CHECK(locked && failed);
      61           9 :     BOOST_CHECK(lock.owns_lock());
      62           1 : }
      63             : 
      64           3 : BOOST_AUTO_TEST_SUITE_END()