testsuite/rw_mutex_test.cpp

   1 #define BOOST_TEST_MAIN
   2 #include <boost/test/included/unit_test.hpp>
   3
   4 #include <boost/shared_ptr.hpp>
   5 #include <boost/thread.hpp>
   6
   7 #include "rw_mutex.hpp"
   8
   9 using namespace nova;
  10
  11 const int thread_count = 8;
  12 const int total_count = 30000;
  13
  14 template <typename Mutex>
  15 void nonrecursive_tests(void)
  16 {
  17     Mutex mut;
  18
  19     typedef boost::shared_lock<Mutex> scoped_read_lock;
  20
  21     mut.lock_shared();
  22     mut.lock_shared();
  23     BOOST_REQUIRE_EQUAL( mut.try_lock(), false );
  24     BOOST_REQUIRE_EQUAL( mut.try_lock_shared(), true );
  25     {
  26         scoped_read_lock lock(mut);
  27     }
  28     mut.unlock_shared();
  29     mut.unlock_shared();
  30     mut.unlock_shared();
  31
  32     BOOST_REQUIRE_EQUAL( mut.try_lock(), true );
  33     mut.unlock();
  34     BOOST_REQUIRE_EQUAL( mut.try_lock_shared(), true );
  35     mut.unlock_shared();
  36 }
  37
  38 template <typename Mutex>
  39 void recursive_tests(void)
  40 {
  41     Mutex mut;
  42
  43     typedef typename Mutex::shared_lock scoped_read_lock;
  44
  45     mut.lock_shared();
  46     mut.lock_shared();
  47     BOOST_REQUIRE_EQUAL( mut.try_lock(), false );
  48     BOOST_REQUIRE_EQUAL( mut.try_lock_shared(), true );
  49     {
  50         scoped_read_lock lock(mut);
  51     }
  52     mut.unlock_shared();
  53     mut.unlock_shared();
  54     mut.unlock_shared();
  55
  56     BOOST_REQUIRE_EQUAL( mut.try_lock(), true );
  57     mut.lock();
  58     mut.lock();
  59     BOOST_REQUIRE_EQUAL( mut.try_lock_shared(), true );
  60     mut.unlock_shared();
  61     mut.unlock();
  62     mut.unlock();
  63     mut.unlock();
  64 }
  65
  66 BOOST_AUTO_TEST_CASE( rw_mutex_test )
  67 {
  68     nonrecursive_tests<rw_mutex>();
  69     nonrecursive_tests<nonrecursive_rw_mutex>();
  70 }
  71
  72 namespace
  73 {
  74     rw_mutex mut;
  75     typedef boost::shared_lock<rw_mutex> scoped_read_lock;
  76     typedef boost::unique_lock<rw_mutex> scoped_write_lock;
  77
  78     void sleep ()
  79     {
  80         boost::thread::yield();
  81     }
  82
  83     void test_fn(void)
  84     {
  85         static rw_mutex mut;
  86
  87         for (int i = 0; i != total_count; ++i)
  88         {
  89             /* recursive read locks */
  90             {
  91                 scoped_read_lock lock(mut);
  92                 sleep();
  93                 {
  94                     scoped_read_lock lock(mut);
  95                     sleep();
  96                 }
  97                 sleep();
  98             }
  99
 100             /* recursive write locks */
 101             {
 102                 scoped_write_lock lock(mut);
 103                 sleep();
 104                 {
 105                     scoped_write_lock lock(mut);
 106                     sleep();
 107                 }
 108                 sleep();
 109             }
 110
 111             /* nested read / write locks */
 112             {
 113                 scoped_write_lock lock(mut);
 114                 sleep();
 115                 {
 116                     scoped_read_lock lock(mut);
 117                     sleep();
 118                 }
 119                 sleep();
 120             }
 121         }
 122     }
 123
 124 }
 125
 126
 127 BOOST_AUTO_TEST_CASE( rw_mutex_test_2 )
 128 {
 129     boost::thread_group threads;
 130     for (int i = 0; i != thread_count; ++i)
 131         threads.create_thread(&test_fn);
 132
 133     threads.join_all();
 134 }