libs/thread/test/sync/mutual_exclusion/sync_queue/single_thread_pass.cpp

   1 // Copyright (C) 2013 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/sync_queue.hpp>
  16
  17 #include <boost/detail/lightweight_test.hpp>
  18
  19 class non_copyable
  20 {
  21   BOOST_THREAD_MOVABLE_ONLY(non_copyable)
  22   int val;
  23 public:
  24   non_copyable(int v) : val(v){}
  25   non_copyable(BOOST_RV_REF(non_copyable) x): val(x.val) {}
  26   non_copyable& operator=(BOOST_RV_REF(non_copyable) x) { val=x.val; return *this; }
  27   bool operator==(non_copyable const& x) const {return val==x.val;}
  28   template <typename OSTREAM>
  29   friend OSTREAM& operator <<(OSTREAM& os, non_copyable const&x )
  30   {
  31     os << x.val;
  32     return os;
  33   }
  34
  35 };
  36
  37
  38
  39 int main()
  40 {
  41
  42   {
  43     // default queue invariants
  44       boost::sync_queue<int> q;
  45       BOOST_TEST(q.empty());
  46       BOOST_TEST(! q.full());
  47       BOOST_TEST_EQ(q.size(), 0u);
  48       BOOST_TEST(! q.closed());
  49   }
  50 #ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
  51   {
  52     // empty queue try_pull fails
  53       boost::sync_queue<int> q;
  54       int i;
  55       BOOST_TEST(! q.try_pull(i));
  56       BOOST_TEST(q.empty());
  57       BOOST_TEST(! q.full());
  58       BOOST_TEST_EQ(q.size(), 0u);
  59       BOOST_TEST(! q.closed());
  60   }
  61   {
  62     // empty queue try_pull fails
  63       boost::sync_queue<int> q;
  64       BOOST_TEST(! q.try_pull());
  65       BOOST_TEST(q.empty());
  66       BOOST_TEST(! q.full());
  67       BOOST_TEST_EQ(q.size(), 0u);
  68       BOOST_TEST(! q.closed());
  69   }
  70   {
  71     // empty queue push rvalue/copyable succeeds
  72       boost::sync_queue<int> q;
  73       q.push(1);
  74       BOOST_TEST(! q.empty());
  75       BOOST_TEST(! q.full());
  76       BOOST_TEST_EQ(q.size(), 1u);
  77       BOOST_TEST(! q.closed());
  78   }
  79   {
  80     // empty queue push lvalue/copyable succeeds
  81       boost::sync_queue<int> q;
  82       int i;
  83       q.push(i);
  84       BOOST_TEST(! q.empty());
  85       BOOST_TEST(! q.full());
  86       BOOST_TEST_EQ(q.size(), 1u);
  87       BOOST_TEST(! q.closed());
  88   }
  89 #endif
  90
  91   {
  92     // empty queue try_pull fails
  93       boost::sync_queue<int> q;
  94       int i;
  95       BOOST_TEST( boost::queue_op_status::empty == q.try_pull_front(i));
  96       BOOST_TEST(q.empty());
  97       BOOST_TEST(! q.full());
  98       BOOST_TEST_EQ(q.size(), 0u);
  99       BOOST_TEST(! q.closed());
 100   }
 101   {
 102     // empty queue push rvalue/copyable succeeds
 103       boost::sync_queue<int> q;
 104       q.push_back(1);
 105       BOOST_TEST(! q.empty());
 106       BOOST_TEST(! q.full());
 107       BOOST_TEST_EQ(q.size(), 1u);
 108       BOOST_TEST(! q.closed());
 109   }
 110   {
 111     // empty queue push lvalue/copyable succeeds
 112       boost::sync_queue<int> q;
 113       int i;
 114       q.push_back(i);
 115       BOOST_TEST(! q.empty());
 116       BOOST_TEST(! q.full());
 117       BOOST_TEST_EQ(q.size(), 1u);
 118       BOOST_TEST(! q.closed());
 119   }
 120
 121 #ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
 122 #if 0
 123   {
 124     // empty queue push rvalue/non_copyable succeeds
 125       boost::sync_queue<non_copyable> q;
 126       q.push(non_copyable(1));
 127       BOOST_TEST(! q.empty());
 128       BOOST_TEST(! q.full());
 129       BOOST_TEST_EQ(q.size(), 1u);
 130       BOOST_TEST(! q.closed());
 131   }
 132 #endif
 133   {
 134     // empty queue push rvalue/non_copyable succeeds
 135       boost::sync_queue<non_copyable> q;
 136       non_copyable nc(1);
 137       q.push(boost::move(nc));
 138       BOOST_TEST(! q.empty());
 139       BOOST_TEST(! q.full());
 140       BOOST_TEST_EQ(q.size(), 1u);
 141       BOOST_TEST(! q.closed());
 142   }
 143
 144   {
 145     // empty queue push rvalue succeeds
 146       boost::sync_queue<int> q;
 147       q.push(1);
 148       q.push(2);
 149       BOOST_TEST(! q.empty());
 150       BOOST_TEST(! q.full());
 151       BOOST_TEST_EQ(q.size(), 2u);
 152       BOOST_TEST(! q.closed());
 153   }
 154   {
 155     // empty queue push lvalue succeeds
 156       boost::sync_queue<int> q;
 157       int i;
 158       q.push(i);
 159       BOOST_TEST(! q.empty());
 160       BOOST_TEST(! q.full());
 161       BOOST_TEST_EQ(q.size(), 1u);
 162       BOOST_TEST(! q.closed());
 163   }
 164   {
 165     // empty queue try_push rvalue/copyable succeeds
 166       boost::sync_queue<int> q;
 167       BOOST_TEST(q.try_push(1));
 168       BOOST_TEST(! q.empty());
 169       BOOST_TEST(! q.full());
 170       BOOST_TEST_EQ(q.size(), 1u);
 171       BOOST_TEST(! q.closed());
 172   }
 173   {
 174     // empty queue try_push rvalue/copyable succeeds
 175       boost::sync_queue<int> q;
 176       BOOST_TEST(q.try_push(1));
 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 #if 0
 184   {
 185     // empty queue push rvalue/non_copyable succeeds
 186       boost::sync_queue<non_copyable> q;
 187       q.push_back(non_copyable(1));
 188       BOOST_TEST(! q.empty());
 189       BOOST_TEST(! q.full());
 190       BOOST_TEST_EQ(q.size(), 1u);
 191       BOOST_TEST(! q.closed());
 192   }
 193 #endif
 194   {
 195     // empty queue push rvalue/non_copyable succeeds
 196       boost::sync_queue<non_copyable> q;
 197       non_copyable nc(1);
 198       q.push_back(boost::move(nc));
 199       BOOST_TEST(! q.empty());
 200       BOOST_TEST(! q.full());
 201       BOOST_TEST_EQ(q.size(), 1u);
 202       BOOST_TEST(! q.closed());
 203   }
 204
 205   {
 206     // empty queue push rvalue succeeds
 207       boost::sync_queue<int> q;
 208       q.push_back(1);
 209       q.push_back(2);
 210       BOOST_TEST(! q.empty());
 211       BOOST_TEST(! q.full());
 212       BOOST_TEST_EQ(q.size(), 2u);
 213       BOOST_TEST(! q.closed());
 214   }
 215   {
 216     // empty queue push lvalue succeeds
 217       boost::sync_queue<int> q;
 218       int i;
 219       q.push_back(i);
 220       BOOST_TEST(! q.empty());
 221       BOOST_TEST(! q.full());
 222       BOOST_TEST_EQ(q.size(), 1u);
 223       BOOST_TEST(! q.closed());
 224   }
 225   {
 226     // empty queue try_push rvalue/copyable succeeds
 227       boost::sync_queue<int> q;
 228       BOOST_TEST(boost::queue_op_status::success == q.try_push_back(1));
 229       BOOST_TEST(! q.empty());
 230       BOOST_TEST(! q.full());
 231       BOOST_TEST_EQ(q.size(), 1u);
 232       BOOST_TEST(! q.closed());
 233   }
 234   {
 235     // empty queue try_push rvalue/copyable succeeds
 236       boost::sync_queue<int> q;
 237       BOOST_TEST(boost::queue_op_status::success == q.try_push_back(1));
 238       BOOST_TEST(! q.empty());
 239       BOOST_TEST(! q.full());
 240       BOOST_TEST_EQ(q.size(), 1u);
 241       BOOST_TEST(! q.closed());
 242   }
 243 #ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
 244 #if 0
 245   {
 246     // empty queue try_push rvalue/non-copyable succeeds
 247       boost::sync_queue<non_copyable> q;
 248       BOOST_TEST(q.try_push(non_copyable()));
 249       BOOST_TEST(! q.empty());
 250       BOOST_TEST(! q.full());
 251       BOOST_TEST_EQ(q.size(), 1u);
 252       BOOST_TEST(! q.closed());
 253   }
 254 #endif
 255   {
 256     // empty queue try_push rvalue/non-copyable succeeds
 257       boost::sync_queue<non_copyable> q;
 258       non_copyable nc(1);
 259       BOOST_TEST(q.try_push(boost::move(nc)));
 260       BOOST_TEST(! q.empty());
 261       BOOST_TEST(! q.full());
 262       BOOST_TEST_EQ(q.size(), 1u);
 263       BOOST_TEST(! q.closed());
 264   }
 265
 266   {
 267     // empty queue try_push lvalue succeeds
 268       boost::sync_queue<int> q;
 269       int i=1;
 270       BOOST_TEST(q.try_push(i));
 271       BOOST_TEST(! q.empty());
 272       BOOST_TEST(! q.full());
 273       BOOST_TEST_EQ(q.size(), 1u);
 274       BOOST_TEST(! q.closed());
 275   }
 276   {
 277     // empty queue try_push rvalue succeeds
 278       boost::sync_queue<int> q;
 279       BOOST_TEST(q.try_push(boost::no_block, 1));
 280       BOOST_TEST(! q.empty());
 281       BOOST_TEST(! q.full());
 282       BOOST_TEST_EQ(q.size(), 1u);
 283       BOOST_TEST(! q.closed());
 284   }
 285 #endif
 286 #if 0
 287   {
 288     // empty queue try_push rvalue/non-copyable succeeds
 289       boost::sync_queue<non_copyable> q;
 290       BOOST_TEST(boost::queue_op_status::success ==q.try_push_back(non_copyable()));
 291       BOOST_TEST(! q.empty());
 292       BOOST_TEST(! q.full());
 293       BOOST_TEST_EQ(q.size(), 1u);
 294       BOOST_TEST(! q.closed());
 295   }
 296 #endif
 297   {
 298     // empty queue try_push rvalue/non-copyable succeeds
 299       boost::sync_queue<non_copyable> q;
 300       non_copyable nc(1);
 301       BOOST_TEST(boost::queue_op_status::success == q.try_push_back(boost::move(nc)));
 302       BOOST_TEST(! q.empty());
 303       BOOST_TEST(! q.full());
 304       BOOST_TEST_EQ(q.size(), 1u);
 305       BOOST_TEST(! q.closed());
 306   }
 307
 308   {
 309     // empty queue try_push lvalue succeeds
 310       boost::sync_queue<int> q;
 311       int i=1;
 312       BOOST_TEST(boost::queue_op_status::success == q.try_push_back(i));
 313       BOOST_TEST(! q.empty());
 314       BOOST_TEST(! q.full());
 315       BOOST_TEST_EQ(q.size(), 1u);
 316       BOOST_TEST(! q.closed());
 317   }
 318   {
 319     // empty queue try_push rvalue succeeds
 320       boost::sync_queue<int> q;
 321       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push_back(1));
 322       BOOST_TEST(! q.empty());
 323       BOOST_TEST(! q.full());
 324       BOOST_TEST_EQ(q.size(), 1u);
 325       BOOST_TEST(! q.closed());
 326   }
 327
 328 #ifndef BOOST_THREAD_QUEUE_DEPRECATE_OLD
 329 #if 0
 330   {
 331     // empty queue try_push rvalue/non-copyable succeeds
 332       boost::sync_queue<non_copyable> q;
 333       BOOST_TEST(q.try_push(boost::no_block, non_copyable(1)));
 334       BOOST_TEST(! q.empty());
 335       BOOST_TEST(! q.full());
 336       BOOST_TEST_EQ(q.size(), 1u);
 337       BOOST_TEST(! q.closed());
 338   }
 339 #endif
 340   {
 341     // empty queue try_push rvalue/non-copyable succeeds
 342       boost::sync_queue<non_copyable> q;
 343       non_copyable nc(1);
 344       BOOST_TEST(q.try_push(boost::no_block, boost::move(nc)));
 345       BOOST_TEST(! q.empty());
 346       BOOST_TEST(! q.full());
 347       BOOST_TEST_EQ(q.size(), 1u);
 348       BOOST_TEST(! q.closed());
 349   }
 350   {
 351     // 1-element queue pull succeed
 352       boost::sync_queue<int> q;
 353       q.push(1);
 354       int i;
 355       q.pull(i);
 356       BOOST_TEST_EQ(i, 1);
 357       BOOST_TEST(q.empty());
 358       BOOST_TEST(! q.full());
 359       BOOST_TEST_EQ(q.size(), 0u);
 360       BOOST_TEST(! q.closed());
 361   }
 362   {
 363     // 1-element queue pull succeed
 364       boost::sync_queue<non_copyable> q;
 365       non_copyable nc1(1);
 366       q.push(boost::move(nc1));
 367       non_copyable nc2(2);
 368       q.pull(nc2);
 369       BOOST_TEST_EQ(nc1, nc2);
 370       BOOST_TEST(q.empty());
 371       BOOST_TEST(! q.full());
 372       BOOST_TEST_EQ(q.size(), 0u);
 373       BOOST_TEST(! q.closed());
 374   }
 375   {
 376     // 1-element queue pull succeed
 377       boost::sync_queue<int> q;
 378       q.push(1);
 379       int i = q.pull();
 380       BOOST_TEST_EQ(i, 1);
 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     // 1-element queue pull succeed
 388       boost::sync_queue<non_copyable> q;
 389       non_copyable nc1(1);
 390       q.push(boost::move(nc1));
 391       non_copyable nc = q.pull();
 392       BOOST_TEST_EQ(nc, nc1);
 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     // 1-element queue try_pull succeed
 400       boost::sync_queue<int> q;
 401       q.push(1);
 402       int i;
 403       BOOST_TEST(q.try_pull(i));
 404       BOOST_TEST_EQ(i, 1);
 405       BOOST_TEST(q.empty());
 406       BOOST_TEST(! q.full());
 407       BOOST_TEST_EQ(q.size(), 0u);
 408       BOOST_TEST(! q.closed());
 409   }
 410   {
 411     // 1-element queue try_pull succeed
 412       boost::sync_queue<non_copyable> q;
 413       non_copyable nc1(1);
 414       q.push(boost::move(nc1));
 415       non_copyable nc(2);
 416       BOOST_TEST(q.try_pull(nc));
 417       BOOST_TEST_EQ(nc, nc1);
 418       BOOST_TEST(q.empty());
 419       BOOST_TEST(! q.full());
 420       BOOST_TEST_EQ(q.size(), 0u);
 421       BOOST_TEST(! q.closed());
 422   }
 423   {
 424     // 1-element queue try_pull succeed
 425       boost::sync_queue<int> q;
 426       q.push(1);
 427       int i;
 428       BOOST_TEST(q.try_pull(boost::no_block, i));
 429       BOOST_TEST_EQ(i, 1);
 430       BOOST_TEST(q.empty());
 431       BOOST_TEST(! q.full());
 432       BOOST_TEST_EQ(q.size(), 0u);
 433       BOOST_TEST(! q.closed());
 434   }
 435   {
 436     // 1-element queue try_pull succeed
 437       boost::sync_queue<non_copyable> q;
 438       non_copyable nc1(1);
 439       q.push(boost::move(nc1));
 440       non_copyable nc(2);
 441       BOOST_TEST(q.try_pull(boost::no_block, nc));
 442       BOOST_TEST_EQ(nc, nc1);
 443       BOOST_TEST(q.empty());
 444       BOOST_TEST(! q.full());
 445       BOOST_TEST_EQ(q.size(), 0u);
 446       BOOST_TEST(! q.closed());
 447   }
 448   {
 449     // 1-element queue try_pull succeed
 450       boost::sync_queue<int> q;
 451       q.push(1);
 452       boost::shared_ptr<int> i = q.try_pull();
 453       BOOST_TEST_EQ(*i, 1);
 454       BOOST_TEST(q.empty());
 455       BOOST_TEST(! q.full());
 456       BOOST_TEST_EQ(q.size(), 0u);
 457       BOOST_TEST(! q.closed());
 458   }
 459
 460   {
 461     // closed invariants
 462       boost::sync_queue<int> q;
 463       q.close();
 464       BOOST_TEST(q.empty());
 465       BOOST_TEST(! q.full());
 466       BOOST_TEST_EQ(q.size(), 0u);
 467       BOOST_TEST(q.closed());
 468   }
 469   {
 470     // closed queue push fails
 471       boost::sync_queue<int> q;
 472       q.close();
 473       try {
 474         q.push(1);
 475         BOOST_TEST(false);
 476       } catch (...) {
 477         BOOST_TEST(q.empty());
 478         BOOST_TEST(! q.full());
 479         BOOST_TEST_EQ(q.size(), 0u);
 480         BOOST_TEST(q.closed());
 481       }
 482   }
 483   {
 484     // closed empty queue try_pull_front closed
 485       boost::sync_queue<int> q;
 486       q.close();
 487       int i;
 488       BOOST_TEST(boost::queue_op_status::closed == q.try_pull_front(i));
 489       BOOST_TEST(q.empty());
 490       BOOST_TEST(! q.full());
 491       BOOST_TEST_EQ(q.size(), 0u);
 492       BOOST_TEST(q.closed());
 493   }
 494   {
 495     // closed empty queue nonblocking_pull_front closed
 496       boost::sync_queue<int> q;
 497       q.close();
 498       int i;
 499       BOOST_TEST(boost::queue_op_status::closed == q.nonblocking_pull_front(i));
 500       BOOST_TEST(q.empty());
 501       BOOST_TEST(! q.full());
 502       BOOST_TEST_EQ(q.size(), 0u);
 503       BOOST_TEST(q.closed());
 504   }
 505   {
 506     // 1-element closed queue pull succeed
 507       boost::sync_queue<int> q;
 508       q.push(1);
 509       q.close();
 510       int i;
 511       q.pull(i);
 512       BOOST_TEST_EQ(i, 1);
 513       BOOST_TEST(q.empty());
 514       BOOST_TEST(! q.full());
 515       BOOST_TEST_EQ(q.size(), 0u);
 516       BOOST_TEST(q.closed());
 517   }
 518 #endif
 519 #if 0
 520   {
 521     // empty queue nonblocking_push_back rvalue/non-copyable succeeds
 522       boost::sync_queue<non_copyable> q;
 523       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push_back(non_copyable(1)));
 524       BOOST_TEST(! q.empty());
 525       BOOST_TEST(! q.full());
 526       BOOST_TEST_EQ(q.size(), 1u);
 527       BOOST_TEST(! q.closed());
 528   }
 529 #endif
 530   {
 531     // empty queue nonblocking_push_back rvalue/non-copyable succeeds
 532       boost::sync_queue<non_copyable> q;
 533       non_copyable nc(1);
 534       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_push_back(boost::move(nc)));
 535       BOOST_TEST(! q.empty());
 536       BOOST_TEST(! q.full());
 537       BOOST_TEST_EQ(q.size(), 1u);
 538       BOOST_TEST(! q.closed());
 539   }
 540   {
 541     // 1-element queue pull_front succeed
 542       boost::sync_queue<int> q;
 543       q.push_back(1);
 544       int i;
 545       q.pull_front(i);
 546       BOOST_TEST_EQ(i, 1);
 547       BOOST_TEST(q.empty());
 548       BOOST_TEST(! q.full());
 549       BOOST_TEST_EQ(q.size(), 0u);
 550       BOOST_TEST(! q.closed());
 551   }
 552   {
 553     // 1-element queue pull_front succeed
 554       boost::sync_queue<non_copyable> q;
 555       non_copyable nc1(1);
 556       q.push_back(boost::move(nc1));
 557       non_copyable nc2(2);
 558       q.pull_front(nc2);
 559       BOOST_TEST_EQ(nc1, nc2);
 560       BOOST_TEST(q.empty());
 561       BOOST_TEST(! q.full());
 562       BOOST_TEST_EQ(q.size(), 0u);
 563       BOOST_TEST(! q.closed());
 564   }
 565   {
 566     // 1-element queue pull_front succeed
 567       boost::sync_queue<int> q;
 568       q.push_back(1);
 569       int i = q.pull_front();
 570       BOOST_TEST_EQ(i, 1);
 571       BOOST_TEST(q.empty());
 572       BOOST_TEST(! q.full());
 573       BOOST_TEST_EQ(q.size(), 0u);
 574       BOOST_TEST(! q.closed());
 575   }
 576   {
 577     // 1-element queue pull_front succeed
 578       boost::sync_queue<non_copyable> q;
 579       non_copyable nc1(1);
 580       q.push_back(boost::move(nc1));
 581       non_copyable nc = q.pull_front();
 582       BOOST_TEST_EQ(nc, nc1);
 583       BOOST_TEST(q.empty());
 584       BOOST_TEST(! q.full());
 585       BOOST_TEST_EQ(q.size(), 0u);
 586       BOOST_TEST(! q.closed());
 587   }
 588   {
 589     // 1-element queue try_pull_front succeed
 590       boost::sync_queue<int> q;
 591       q.push_back(1);
 592       int i;
 593       BOOST_TEST(boost::queue_op_status::success == q.try_pull_front(i));
 594       BOOST_TEST_EQ(i, 1);
 595       BOOST_TEST(q.empty());
 596       BOOST_TEST(! q.full());
 597       BOOST_TEST_EQ(q.size(), 0u);
 598       BOOST_TEST(! q.closed());
 599   }
 600   {
 601     // 1-element queue try_pull_front succeed
 602       boost::sync_queue<non_copyable> q;
 603       non_copyable nc1(1);
 604       q.push_back(boost::move(nc1));
 605       non_copyable nc(2);
 606       BOOST_TEST(boost::queue_op_status::success == q.try_pull_front(nc));
 607       BOOST_TEST_EQ(nc, nc1);
 608       BOOST_TEST(q.empty());
 609       BOOST_TEST(! q.full());
 610       BOOST_TEST_EQ(q.size(), 0u);
 611       BOOST_TEST(! q.closed());
 612   }
 613   {
 614     // 1-element queue nonblocking_pull_front succeed
 615       boost::sync_queue<int> q;
 616       q.push_back(1);
 617       int i;
 618       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull_front(i));
 619       BOOST_TEST_EQ(i, 1);
 620       BOOST_TEST(q.empty());
 621       BOOST_TEST(! q.full());
 622       BOOST_TEST_EQ(q.size(), 0u);
 623       BOOST_TEST(! q.closed());
 624   }
 625   {
 626     // 1-element queue nonblocking_pull_front succeed
 627       boost::sync_queue<non_copyable> q;
 628       non_copyable nc1(1);
 629       q.push_back(boost::move(nc1));
 630       non_copyable nc(2);
 631       BOOST_TEST(boost::queue_op_status::success == q.nonblocking_pull_front(nc));
 632       BOOST_TEST_EQ(nc, nc1);
 633       BOOST_TEST(q.empty());
 634       BOOST_TEST(! q.full());
 635       BOOST_TEST_EQ(q.size(), 0u);
 636       BOOST_TEST(! q.closed());
 637   }
 638   {
 639     // 1-element queue wait_pull_front succeed
 640       boost::sync_queue<non_copyable> q;
 641       non_copyable nc1(1);
 642       q.push_back(boost::move(nc1));
 643       non_copyable nc(2);
 644       BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(nc));
 645       BOOST_TEST_EQ(nc, nc1);
 646       BOOST_TEST(q.empty());
 647       BOOST_TEST(! q.full());
 648       BOOST_TEST_EQ(q.size(), 0u);
 649       BOOST_TEST(! q.closed());
 650   }
 651   {
 652     // 1-element queue wait_pull_front succeed
 653       boost::sync_queue<int> q;
 654       q.push_back(1);
 655       int i;
 656       BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(i));
 657       BOOST_TEST_EQ(i, 1);
 658       BOOST_TEST(q.empty());
 659       BOOST_TEST(! q.full());
 660       BOOST_TEST_EQ(q.size(), 0u);
 661       BOOST_TEST(! q.closed());
 662   }
 663   {
 664     // 1-element queue wait_pull_front succeed
 665       boost::sync_queue<non_copyable> q;
 666       non_copyable nc1(1);
 667       q.push_back(boost::move(nc1));
 668       non_copyable nc(2);
 669       BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(nc));
 670       BOOST_TEST_EQ(nc, nc1);
 671       BOOST_TEST(q.empty());
 672       BOOST_TEST(! q.full());
 673       BOOST_TEST_EQ(q.size(), 0u);
 674       BOOST_TEST(! q.closed());
 675   }
 676
 677   {
 678     // closed invariants
 679       boost::sync_queue<int> q;
 680       q.close();
 681       BOOST_TEST(q.empty());
 682       BOOST_TEST(! q.full());
 683       BOOST_TEST_EQ(q.size(), 0u);
 684       BOOST_TEST(q.closed());
 685   }
 686   {
 687     // closed queue push fails
 688       boost::sync_queue<int> q;
 689       q.close();
 690       try {
 691         q.push_back(1);
 692         BOOST_TEST(false);
 693       } catch (...) {
 694         BOOST_TEST(q.empty());
 695         BOOST_TEST(! q.full());
 696         BOOST_TEST_EQ(q.size(), 0u);
 697         BOOST_TEST(q.closed());
 698       }
 699   }
 700   {
 701     // 1-element closed queue pull succeed
 702       boost::sync_queue<int> q;
 703       q.push_back(1);
 704       q.close();
 705       int i;
 706       q.pull_front(i);
 707       BOOST_TEST_EQ(i, 1);
 708       BOOST_TEST(q.empty());
 709       BOOST_TEST(! q.full());
 710       BOOST_TEST_EQ(q.size(), 0u);
 711       BOOST_TEST(q.closed());
 712   }
 713   {
 714     // 1-element closed queue wait_pull_front succeed
 715       boost::sync_queue<int> q;
 716       q.push_back(1);
 717       q.close();
 718       int i;
 719       BOOST_TEST(boost::queue_op_status::success == q.wait_pull_front(i));
 720       BOOST_TEST_EQ(i, 1);
 721       BOOST_TEST(q.empty());
 722       BOOST_TEST(! q.full());
 723       BOOST_TEST_EQ(q.size(), 0u);
 724       BOOST_TEST(q.closed());
 725   }
 726   {
 727     // closed empty queue wait_pull_front fails
 728       boost::sync_queue<int> q;
 729       q.close();
 730       BOOST_TEST(q.empty());
 731       BOOST_TEST(q.closed());
 732       int i;
 733       BOOST_TEST(boost::queue_op_status::closed == q.wait_pull_front(i));
 734       BOOST_TEST(q.empty());
 735       BOOST_TEST(q.closed());
 736   }
 737
 738   return boost::report_errors();
 739 }
 740