ceph/src/boost/libs/thread/test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp

   1 // Copyright (C) 2014 Ian Forbed
   2 // Copyright (C) 2014,2015 Vicente J. Botet Escriba
   3 //
   4 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
   5 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7
   8 #include <boost/config.hpp>
   9 #if ! defined  BOOST_NO_CXX11_DECLTYPE
  10 #define BOOST_RESULT_OF_USE_DECLTYPE
  11 #endif
  12
  13 #define BOOST_THREAD_VERSION 4
  14 #define BOOST_THREAD_PROVIDES_EXECUTORS
  15
  16 #include <iostream>
  17
  18 #include <boost/thread.hpp>
  19 #include <boost/chrono.hpp>
  20 #include <boost/thread/concurrent_queues/sync_priority_queue.hpp>
  21
  22 #include <boost/detail/lightweight_test.hpp>
  23
  24 using namespace boost::chrono;
  25
  26 typedef boost::concurrent::sync_priority_queue<int> sync_pq;
  27
  28 class non_copyable
  29 {
  30   BOOST_THREAD_MOVABLE_ONLY(non_copyable)
  31   int val;
  32 public:
  33   non_copyable(int v) : val(v){}
  34   non_copyable(BOOST_RV_REF(non_copyable) x): val(x.val) {}
  35   non_copyable& operator=(BOOST_RV_REF(non_copyable) x) { val=x.val; return *this; }
  36   bool operator==(non_copyable const& x) const {return val==x.val;}
  37   template <typename OSTREAM>
  38   friend OSTREAM& operator <<(OSTREAM& os, non_copyable const&x )
  39   {
  40     os << x.val;
  41     return os;
  42   }
  43   bool operator <(const non_copyable& other) const
  44   {
  45     return val < other.val;
  46   }
  47 };
  48
  49
  50 void test_pull_for()
  51 {
  52   sync_pq pq;
  53   steady_clock::time_point start = steady_clock::now();
  54   int val;
  55   boost::queue_op_status st = pq.pull_for(milliseconds(500), val);
  56   steady_clock::duration diff = steady_clock::now() - start;
  57   BOOST_TEST(boost::queue_op_status::timeout == st);
  58   BOOST_TEST(diff < milliseconds(550) && diff > milliseconds(500));
  59 }
  60
  61 void test_pull_until()
  62 {
  63   sync_pq pq;
  64   steady_clock::time_point start = steady_clock::now();
  65   int val;
  66   boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val);
  67   steady_clock::duration diff = steady_clock::now() - start;
  68   BOOST_TEST(boost::queue_op_status::timeout == st);
  69   BOOST_TEST(diff < milliseconds(550) && diff > milliseconds(500));
  70 }
  71
  72 void test_nonblocking_pull()
  73 {
  74   sync_pq pq;
  75   steady_clock::time_point start = steady_clock::now();
  76   int val;
  77   boost::queue_op_status st = pq.nonblocking_pull(val);
  78   steady_clock::duration diff = steady_clock::now() - start;
  79   BOOST_TEST(boost::queue_op_status::empty == st);
  80   BOOST_TEST(diff < milliseconds(5));
  81 }
  82
  83 void test_pull_for_when_not_empty()
  84 {
  85   sync_pq pq;
  86   pq.push(1);
  87   steady_clock::time_point start = steady_clock::now();
  88   int val;
  89   boost::queue_op_status st = pq.pull_for(milliseconds(500), val);
  90   steady_clock::duration diff = steady_clock::now() - start;
  91   BOOST_TEST(boost::queue_op_status::success == st);
  92   BOOST_TEST(1 == val);
  93   BOOST_TEST(diff < milliseconds(5));
  94 }
  95
  96 void test_pull_until_when_not_empty()
  97 {
  98   sync_pq pq;
  99   pq.push(1);
 100   steady_clock::time_point start = steady_clock::now();
 101   int val;
 102   boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val);
 103   steady_clock::duration diff = steady_clock::now() - start;
 104   BOOST_TEST(boost::queue_op_status::success == st);
 105   BOOST_TEST(1 == val);
 106   BOOST_TEST(diff < milliseconds(5));
 107 }
 108
 109 int main()
 110 {
 111   sync_pq pq;
 112   BOOST_TEST(pq.empty());
 113   BOOST_TEST(!pq.closed());
 114   BOOST_TEST_EQ(pq.size(), std::size_t(0));
 115
 116   for(int i = 1; i <= 5; i++){
 117     pq.push(i);
 118     BOOST_TEST(!pq.empty());
 119     BOOST_TEST_EQ(pq.size(), std::size_t(i));
 120   }
 121
 122   for(int i = 6; i <= 10; i++){
 123     boost::queue_op_status succ = pq.try_push(i);
 124     BOOST_TEST(succ == boost::queue_op_status::success );
 125     BOOST_TEST(!pq.empty());
 126     BOOST_TEST_EQ(pq.size(), std::size_t(i));
 127   }
 128
 129   for(int i = 10; i > 5; i--){
 130     int val = pq.pull();
 131     BOOST_TEST_EQ(val, i);
 132   }
 133
 134 //  for(int i = 5; i > 0; i--){
 135 //    boost::optional<int> val = pq.try_pull();
 136 //    BOOST_TEST(val);
 137 //    BOOST_TEST_EQ(*val, i);
 138 //  }
 139
 140 //  BOOST_TEST(pq.empty());
 141   pq.close();
 142   BOOST_TEST(pq.closed());
 143
 144   test_pull_for();
 145   test_pull_until();
 146   test_nonblocking_pull();
 147
 148   test_pull_for_when_not_empty();
 149   //test_pull_until_when_not_empty();
 150
 151 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 152   {
 153     // empty queue try_push rvalue/non-copyable succeeds
 154       boost::concurrent::sync_priority_queue<non_copyable> q;
 155       BOOST_TEST(boost::queue_op_status::success ==q.try_push(non_copyable(1)));
 156       BOOST_TEST(! q.empty());
 157       BOOST_TEST(! q.full());
 158       BOOST_TEST_EQ(q.size(), 1u);
 159       BOOST_TEST(! q.closed());
 160   }
 161   {
 162     //fixme
 163     // empty queue try_push rvalue/non-copyable succeeds
 164       boost::concurrent::sync_priority_queue<non_copyable> q;
 165       non_copyable nc(1);
 166       BOOST_TEST(boost::queue_op_status::success == q.try_push(boost::move(nc)));
 167       BOOST_TEST(! q.empty());
 168       BOOST_TEST(! q.full());
 169       BOOST_TEST_EQ(q.size(), 1u);
 170       BOOST_TEST(! q.closed());
 171   }
 172 #endif
 173
 174   {
 175     // empty queue try_push lvalue succeeds
 176       boost::concurrent::sync_priority_queue<int> q;
 177       int i=1;
 178       BOOST_TEST(boost::queue_op_status::success == q.try_push(i));
 179       BOOST_TEST(! q.empty());
 180       BOOST_TEST(! q.full());
 181       BOOST_TEST_EQ(q.size(), 1u);
 182       BOOST_TEST(! q.closed());
 183   }
 184 #if 0
 185   {
 186     // empty queue try_push rvalue succeeds
 187       boost::concurrent::sync_priority_queue<int> q;
 188       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(1));
 189       BOOST_TEST(! q.empty());
 190       BOOST_TEST(! q.full());
 191       BOOST_TEST_EQ(q.size(), 1u);
 192       BOOST_TEST(! q.closed());
 193   }
 194   {
 195     // empty queue nonblocking_push rvalue/non-copyable succeeds
 196       boost::concurrent::sync_priority_queue<non_copyable> q;
 197       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(non_copyable(1)));
 198       BOOST_TEST(! q.empty());
 199       BOOST_TEST(! q.full());
 200       BOOST_TEST_EQ(q.size(), 1u);
 201       BOOST_TEST(! q.closed());
 202   }
 203   {
 204     // empty queue nonblocking_push rvalue/non-copyable succeeds
 205       boost::concurrent::sync_priority_queue<non_copyable> q;
 206       non_copyable nc(1);
 207       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push(boost::move(nc)));
 208       BOOST_TEST(! q.empty());
 209       BOOST_TEST(! q.full());
 210       BOOST_TEST_EQ(q.size(), 1u);
 211       BOOST_TEST(! q.closed());
 212   }
 213 #endif
 214
 215   {
 216     // 1-element queue pull succeed
 217       boost::concurrent::sync_priority_queue<int> q;
 218       q.push(1);
 219       int i;
 220       i=q.pull();
 221       BOOST_TEST_EQ(i, 1);
 222       BOOST_TEST(q.empty());
 223       BOOST_TEST(! q.full());
 224       BOOST_TEST_EQ(q.size(), 0u);
 225       BOOST_TEST(! q.closed());
 226   }
 227 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 228   {
 229     // 1-element queue pull succeed
 230       boost::concurrent::sync_priority_queue<non_copyable> q;
 231       non_copyable nc1(1);
 232       q.push(boost::move(nc1));
 233       non_copyable nc2(2);
 234       nc2=q.pull();
 235       BOOST_TEST_EQ(nc1, nc2);
 236       BOOST_TEST(q.empty());
 237       BOOST_TEST(! q.full());
 238       BOOST_TEST_EQ(q.size(), 0u);
 239       BOOST_TEST(! q.closed());
 240   }
 241 #endif
 242
 243   {
 244     // 1-element queue pull succeed
 245       boost::concurrent::sync_priority_queue<int> q;
 246       q.push(1);
 247       int i = q.pull();
 248       BOOST_TEST_EQ(i, 1);
 249       BOOST_TEST(q.empty());
 250       BOOST_TEST(! q.full());
 251       BOOST_TEST_EQ(q.size(), 0u);
 252       BOOST_TEST(! q.closed());
 253   }
 254 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 255   {
 256     // 1-element queue pull succeed
 257       boost::concurrent::sync_priority_queue<non_copyable> q;
 258       non_copyable nc1(1);
 259       q.push(boost::move(nc1));
 260       non_copyable nc = q.pull();
 261       BOOST_TEST_EQ(nc, nc1);
 262       BOOST_TEST(q.empty());
 263       BOOST_TEST(! q.full());
 264       BOOST_TEST_EQ(q.size(), 0u);
 265       BOOST_TEST(! q.closed());
 266   }
 267 #endif
 268
 269   {
 270     // 1-element queue try_pull succeed
 271       boost::concurrent::sync_priority_queue<int> q;
 272       q.push(1);
 273       int i;
 274       BOOST_TEST(boost::queue_op_status::success == q.try_pull(i));
 275       BOOST_TEST_EQ(i, 1);
 276       BOOST_TEST(q.empty());
 277       BOOST_TEST(! q.full());
 278       BOOST_TEST_EQ(q.size(), 0u);
 279       BOOST_TEST(! q.closed());
 280   }
 281 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 282   {
 283     // 1-element queue try_pull succeed
 284       boost::concurrent::sync_priority_queue<non_copyable> q;
 285       non_copyable nc1(1);
 286       q.push(boost::move(nc1));
 287       non_copyable nc(2);
 288       BOOST_TEST(boost::queue_op_status::success == q.try_pull(nc));
 289       BOOST_TEST_EQ(nc, nc1);
 290       BOOST_TEST(q.empty());
 291       BOOST_TEST(! q.full());
 292       BOOST_TEST_EQ(q.size(), 0u);
 293       BOOST_TEST(! q.closed());
 294   }
 295 #endif
 296   {
 297     // 1-element queue nonblocking_pull succeed
 298       boost::concurrent::sync_priority_queue<int> q;
 299       q.push(1);
 300       int i;
 301       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull(i));
 302       BOOST_TEST_EQ(i, 1);
 303       BOOST_TEST(q.empty());
 304       BOOST_TEST(! q.full());
 305       BOOST_TEST_EQ(q.size(), 0u);
 306       BOOST_TEST(! q.closed());
 307   }
 308 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 309   {
 310     // 1-element queue nonblocking_pull succeed
 311       boost::concurrent::sync_priority_queue<non_copyable> q;
 312       non_copyable nc1(1);
 313       q.push(boost::move(nc1));
 314       non_copyable nc(2);
 315       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull(nc));
 316       BOOST_TEST_EQ(nc, nc1);
 317       BOOST_TEST(q.empty());
 318       BOOST_TEST(! q.full());
 319       BOOST_TEST_EQ(q.size(), 0u);
 320       BOOST_TEST(! q.closed());
 321   }
 322   {
 323     // 1-element queue wait_pull succeed
 324       boost::concurrent::sync_priority_queue<non_copyable> q;
 325       non_copyable nc1(1);
 326       q.push(boost::move(nc1));
 327       non_copyable nc(2);
 328       BOOST_TEST(boost::queue_op_status::success == q.wait_pull(nc));
 329       BOOST_TEST_EQ(nc, nc1);
 330       BOOST_TEST(q.empty());
 331       BOOST_TEST(! q.full());
 332       BOOST_TEST_EQ(q.size(), 0u);
 333       BOOST_TEST(! q.closed());
 334   }
 335 #endif
 336   {
 337     // 1-element queue wait_pull succeed
 338       boost::concurrent::sync_priority_queue<int> q;
 339       q.push(1);
 340       int i;
 341       BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i));
 342       BOOST_TEST_EQ(i, 1);
 343       BOOST_TEST(q.empty());
 344       BOOST_TEST(! q.full());
 345       BOOST_TEST_EQ(q.size(), 0u);
 346       BOOST_TEST(! q.closed());
 347   }
 348 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 349   {
 350     // 1-element queue wait_pull succeed
 351       boost::concurrent::sync_priority_queue<non_copyable> q;
 352       non_copyable nc1(1);
 353       q.push(boost::move(nc1));
 354       non_copyable nc(2);
 355       BOOST_TEST(boost::queue_op_status::success == q.wait_pull(nc));
 356       BOOST_TEST_EQ(nc, nc1);
 357       BOOST_TEST(q.empty());
 358       BOOST_TEST(! q.full());
 359       BOOST_TEST_EQ(q.size(), 0u);
 360       BOOST_TEST(! q.closed());
 361   }
 362 #endif
 363
 364   {
 365     // closed invariants
 366       boost::concurrent::sync_priority_queue<int> q;
 367       q.close();
 368       BOOST_TEST(q.empty());
 369       BOOST_TEST(! q.full());
 370       BOOST_TEST_EQ(q.size(), 0u);
 371       BOOST_TEST(q.closed());
 372   }
 373   {
 374     // closed queue push fails
 375       boost::concurrent::sync_priority_queue<int> q;
 376       q.close();
 377       try {
 378         q.push(1);
 379         BOOST_TEST(false); // fixme
 380       } catch (...) {
 381         BOOST_TEST(q.empty());
 382         BOOST_TEST(! q.full());
 383         BOOST_TEST_EQ(q.size(), 0u);
 384         BOOST_TEST(q.closed());
 385       }
 386   }
 387   {
 388     // 1-element closed queue pull succeed
 389       boost::concurrent::sync_priority_queue<int> q;
 390       q.push(1);
 391       q.close();
 392       int i;
 393       i=q.pull();
 394       BOOST_TEST_EQ(i, 1);
 395       BOOST_TEST(q.empty());
 396       BOOST_TEST(! q.full());
 397       BOOST_TEST_EQ(q.size(), 0u);
 398       BOOST_TEST(q.closed());
 399   }
 400   {
 401     // 1-element closed queue wait_pull succeed
 402       boost::concurrent::sync_priority_queue<int> q;
 403       q.push(1);
 404       q.close();
 405       int i;
 406       BOOST_TEST(boost::queue_op_status::success == q.wait_pull(i));
 407       BOOST_TEST_EQ(i, 1);
 408       BOOST_TEST(q.empty());
 409       BOOST_TEST(! q.full());
 410       BOOST_TEST_EQ(q.size(), 0u);
 411       BOOST_TEST(q.closed());
 412   }
 413   {
 414     // closed empty queue wait_pull fails
 415       boost::concurrent::sync_priority_queue<int> q;
 416       q.close();
 417       BOOST_TEST(q.empty());
 418       BOOST_TEST(q.closed());
 419       int i;
 420       BOOST_TEST(boost::queue_op_status::closed == q.wait_pull(i));
 421       BOOST_TEST(q.empty());
 422       BOOST_TEST(q.closed());
 423   }
 424   return boost::report_errors();
 425 }