LCOV - code coverage report
Current view: top level - src/test - reverselock_tests.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 100.0 % 50 50
Test Date: 2025-08-25 05:11:47 Functions: 100.0 % 6 6
Branches: 50.0 % 280 140

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2015-2021 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 <sync.h>
       6                 :             : #include <test/util/setup_common.h>
       7                 :             : 
       8                 :             : #include <boost/test/unit_test.hpp>
       9                 :             : 
      10                 :             : #include <stdexcept>
      11                 :             : 
      12                 :             : BOOST_AUTO_TEST_SUITE(reverselock_tests)
      13                 :             : 
      14   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(reverselock_basics)
          +  -  +  -  -  
          +  +  -  +  -  
          +  -  +  -  +  
          -  -  +  +  -  
          +  -  +  -  +  
          -  +  -  -  +  
          +  -  +  -  +  
          -  +  -  +  -  
          -  +  +  -  +  
          -  +  -  +  -  
          +  -  -  +  +  
                      - ]
      15                 :             : {
      16                 :           1 :     Mutex mutex;
      17                 :           1 :     WAIT_LOCK(mutex, lock);
      18                 :             : 
      19   [ +  -  +  -  :           2 :     BOOST_CHECK(lock.owns_lock());
                   +  - ]
      20                 :           1 :     AssertLockHeld(mutex);
      21                 :           1 :     {
      22         [ +  - ]:           1 :         REVERSE_LOCK(lock, mutex);
      23                 :           1 :         AssertLockNotHeld(mutex);
      24   [ +  -  +  - ]:           2 :         BOOST_CHECK(!lock.owns_lock());
      25                 :           1 :     }
      26   [ +  -  +  -  :           2 :     BOOST_CHECK(lock.owns_lock());
                   +  - ]
      27                 :           1 : }
      28                 :             : 
      29   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(reverselock_multiple)
          +  -  +  -  -  
          +  +  -  +  -  
          +  -  +  -  +  
          -  -  +  +  -  
          +  -  +  -  +  
          -  +  -  -  +  
          +  -  +  -  +  
          -  +  -  +  -  
          -  +  +  -  +  
          -  +  -  +  -  
          +  -  -  +  +  
                      - ]
      30                 :             : {
      31                 :           1 :     Mutex mutex2;
      32                 :           1 :     Mutex mutex;
      33                 :           1 :     WAIT_LOCK(mutex2, lock2);
      34         [ +  - ]:           1 :     WAIT_LOCK(mutex, lock);
      35                 :             : 
      36                 :             :     // Make sure undoing two locks succeeds
      37                 :           1 :     {
      38         [ +  - ]:           1 :         REVERSE_LOCK(lock, mutex);
      39   [ +  -  +  - ]:           1 :         BOOST_CHECK(!lock.owns_lock());
      40         [ +  - ]:           1 :         REVERSE_LOCK(lock2, mutex2);
      41   [ +  -  +  - ]:           2 :         BOOST_CHECK(!lock2.owns_lock());
      42                 :           1 :     }
      43   [ +  -  +  -  :           2 :     BOOST_CHECK(lock.owns_lock());
                   +  - ]
      44   [ +  -  +  -  :           2 :     BOOST_CHECK(lock2.owns_lock());
                   +  - ]
      45         [ +  - ]:           2 : }
      46                 :             : 
      47   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(reverselock_errors)
          +  -  +  -  -  
          +  +  -  +  -  
          +  -  +  -  +  
          -  -  +  +  -  
          +  -  +  -  +  
          -  +  -  -  +  
          +  -  +  -  +  
          -  +  -  +  -  
          -  +  +  -  +  
          -  +  -  +  -  
          +  -  -  +  +  
                      - ]
      48                 :             : {
      49                 :           1 :     Mutex mutex2;
      50                 :           1 :     Mutex mutex;
      51                 :           1 :     WAIT_LOCK(mutex2, lock2);
      52         [ +  - ]:           1 :     WAIT_LOCK(mutex, lock);
      53                 :             : 
      54                 :             : #ifdef DEBUG_LOCKORDER
      55                 :             :     bool prev = g_debug_lockorder_abort;
      56                 :             :     g_debug_lockorder_abort = false;
      57                 :             : 
      58                 :             :     // Make sure trying to reverse lock a previous lock fails
      59                 :             :     BOOST_CHECK_EXCEPTION(REVERSE_LOCK(lock2, mutex2), std::logic_error, HasReason("mutex2 was not most recent critical section locked"));
      60                 :             :     BOOST_CHECK(lock2.owns_lock());
      61                 :             : 
      62                 :             :     g_debug_lockorder_abort = prev;
      63                 :             : #endif
      64                 :             : 
      65                 :             :     // Make sure trying to reverse lock an unlocked lock fails
      66         [ +  - ]:           1 :     lock.unlock();
      67                 :             : 
      68   [ +  -  +  -  :           2 :     BOOST_CHECK(!lock.owns_lock());
                   -  + ]
      69                 :             : 
      70                 :           1 :     bool failed = false;
      71                 :           1 :     try {
      72         [ -  + ]:           1 :         REVERSE_LOCK(lock, mutex);
      73                 :           1 :     } catch(...) {
      74                 :           1 :         failed = true;
      75         [ +  - ]:           1 :     }
      76                 :             : 
      77   [ +  -  +  -  :           2 :     BOOST_CHECK(failed);
                   +  - ]
      78   [ +  -  +  -  :           2 :     BOOST_CHECK(!lock.owns_lock());
                   +  - ]
      79                 :             : 
      80                 :             :     // Locking the original lock after it has been taken by a reverse lock
      81                 :             :     // makes no sense. Ensure that the original lock no longer owns the lock
      82                 :             :     // after giving it to a reverse one.
      83                 :             : 
      84         [ +  - ]:           1 :     lock.lock();
      85   [ +  -  +  -  :           2 :     BOOST_CHECK(lock.owns_lock());
                   +  - ]
      86                 :           1 :     {
      87         [ +  - ]:           1 :         REVERSE_LOCK(lock, mutex);
      88   [ +  -  +  - ]:           2 :         BOOST_CHECK(!lock.owns_lock());
      89                 :           1 :     }
      90                 :             : 
      91   [ +  -  +  -  :           2 :     BOOST_CHECK(failed);
                   +  - ]
      92   [ +  -  +  -  :           2 :     BOOST_CHECK(lock.owns_lock());
                   +  - ]
      93         [ +  - ]:           2 : }
      94                 :             : 
      95                 :             : BOOST_AUTO_TEST_SUITE_END()
        

Generated by: LCOV version 2.0-1