bitcoin-test 0.1.12-alpha.0

test framework for the bitcoin system
Documentation
crate::ix!();



//-------------------------------------------[.cpp/bitcoin/src/test/reverselock_tests.cpp]

#[cfg(test)]
pub mod reverselock_tests {

    #[test] fn reverselock_basics() {
        todo!();
        /*
        
            Mutex mutex;
            WAIT_LOCK(mutex, lock);

            BOOST_CHECK(lock.owns_lock());
            {
                REVERSE_LOCK(lock);
                BOOST_CHECK(!lock.owns_lock());
            }
            BOOST_CHECK(lock.owns_lock());

        */
    }

    #[test] fn reverselock_multiple() {
        todo!();
        /*
        
            Mutex mutex2;
            Mutex mutex;
            WAIT_LOCK(mutex2, lock2);
            WAIT_LOCK(mutex, lock);

            // Make sure undoing two locks succeeds
            {
                REVERSE_LOCK(lock);
                BOOST_CHECK(!lock.owns_lock());
                REVERSE_LOCK(lock2);
                BOOST_CHECK(!lock2.owns_lock());
            }
            BOOST_CHECK(lock.owns_lock());
            BOOST_CHECK(lock2.owns_lock());

        */
    }

    #[test] fn reverselock_errors() {
        todo!();
        /*
        
            Mutex mutex2;
            Mutex mutex;
            WAIT_LOCK(mutex2, lock2);
            WAIT_LOCK(mutex, lock);

        #ifdef DEBUG_LOCKORDER
            bool prev = g_debug_lockorder_abort;
            g_debug_lockorder_abort = false;

            // Make sure trying to reverse lock a previous lock fails
            BOOST_CHECK_EXCEPTION(REVERSE_LOCK(lock2), std::logic_error, HasReason("lock2 was not most recent critical section locked"));
            BOOST_CHECK(lock2.owns_lock());

            g_debug_lockorder_abort = prev;
        #endif

            // Make sure trying to reverse lock an unlocked lock fails
            lock.unlock();

            BOOST_CHECK(!lock.owns_lock());

            bool failed = false;
            try {
                REVERSE_LOCK(lock);
            } catch(...) {
                failed = true;
            }

            BOOST_CHECK(failed);
            BOOST_CHECK(!lock.owns_lock());

            // Locking the original lock after it has been taken by a reverse lock
            // makes no sense. Ensure that the original lock no longer owns the lock
            // after giving it to a reverse one.

            lock.lock();
            BOOST_CHECK(lock.owns_lock());
            {
                REVERSE_LOCK(lock);
                BOOST_CHECK(!lock.owns_lock());
            }

            BOOST_CHECK(failed);
            BOOST_CHECK(lock.owns_lock());

        */
    }
}