ceph/src/boost/libs/thread/test/sync/mutual_exclusion/queue_views/single_thread_pass.cpp

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