LCOV - code coverage report
Current view: top level - src/test - reverselock_tests.cpp (source / functions) Coverage Total Hit
Test: test_bitcoin_coverage.info Lines: 100.0 % 48 48
Test Date: 2024-11-04 04:45:35 Functions: 100.0 % 6 6
Branches: 50.0 % 254 127

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

Generated by: LCOV version 2.0-1