ceph/src/boost/libs/thread/test/sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // Copyright (C) 2011 Vicente J. Botet Escriba
  11 //
  12 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  13 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  14
  15 // <boost/thread/locks.hpp>
  16
  17 // template <class Mutex> class shared_lock;
  18
  19 // void lock();
  20
  21 #include <boost/thread/lock_types.hpp>
  22 #include <boost/thread/shared_mutex.hpp>
  23 #include <boost/thread/thread.hpp>
  24 #include <boost/detail/lightweight_test.hpp>
  25 #include <iostream>
  26
  27 boost::shared_mutex m;
  28
  29 #if defined BOOST_THREAD_USES_CHRONO
  30 typedef boost::chrono::system_clock Clock;
  31 typedef Clock::time_point time_point;
  32 typedef Clock::duration duration;
  33 typedef boost::chrono::milliseconds ms;
  34 typedef boost::chrono::nanoseconds ns;
  35 #else
  36 #endif
  37
  38 #ifdef BOOST_THREAD_PLATFORM_WIN32
  39 const ms max_diff(250);
  40 #else
  41 const ms max_diff(75);
  42 #endif
  43
  44 void f()
  45 {
  46 #if defined BOOST_THREAD_USES_CHRONO
  47   boost::shared_lock < boost::shared_mutex > lk(m, boost::defer_lock);
  48   time_point t0 = Clock::now();
  49   lk.lock();
  50   time_point t1 = Clock::now();
  51   BOOST_TEST(lk.owns_lock() == true);
  52   ns d = t1 - t0 - ms(250);
  53   BOOST_TEST(d < max_diff);
  54   try
  55   {
  56     lk.lock();
  57     BOOST_TEST(false);
  58   }
  59   catch (boost::system::system_error& e)
  60   {
  61     BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
  62   }
  63   lk.unlock();
  64   lk.release();
  65   try
  66   {
  67     lk.lock();
  68     BOOST_TEST(false);
  69   }
  70   catch (boost::system::system_error& e)
  71   {
  72     BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
  73   }
  74 #else
  75   boost::shared_lock < boost::shared_mutex > lk(m, boost::defer_lock);
  76   //time_point t0 = Clock::now();
  77   lk.lock();
  78   //time_point t1 = Clock::now();
  79   BOOST_TEST(lk.owns_lock() == true);
  80   //ns d = t1 - t0 - ms(250);
  81   //BOOST_TEST(d < max_diff);
  82   try
  83   {
  84     lk.lock();
  85     BOOST_TEST(false);
  86   }
  87   catch (boost::system::system_error& e)
  88   {
  89     BOOST_TEST(e.code().value() == boost::system::errc::resource_deadlock_would_occur);
  90   }
  91   lk.unlock();
  92   lk.release();
  93   try
  94   {
  95     lk.lock();
  96     BOOST_TEST(false);
  97   }
  98   catch (boost::system::system_error& e)
  99   {
 100     BOOST_TEST(e.code().value() == boost::system::errc::operation_not_permitted);
 101   }
 102 #endif
 103 }
 104
 105 int main()
 106 {
 107   m.lock();
 108   boost::thread t(f);
 109 #if defined BOOST_THREAD_USES_CHRONO
 110   boost::this_thread::sleep_for(ms(250));
 111 #else
 112 #endif
 113   m.unlock();
 114   t.join();
 115
 116   return boost::report_errors();
 117 }
 118