ceph/src/boost/libs/move/test/unique_ptr_observers.cpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Howard Hinnant 2009
   4 // (C) Copyright Ion Gaztanaga 2014-2014.
   5 //
   6 // Distributed under the Boost Software License, Version 1.0.
   7 // (See accompanying file LICENSE_1_0.txt or copy at
   8 // http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10 // See http://www.boost.org/libs/move for documentation.
  11 //
  12 //////////////////////////////////////////////////////////////////////////////
  13 #include <boost/move/utility_core.hpp>
  14 #include <boost/move/unique_ptr.hpp>
  15 #include <boost/static_assert.hpp>
  16 #include <boost/core/lightweight_test.hpp>
  17
  18 //////////////////////////////////////////////
  19 //
  20 // The initial implementation of these tests
  21 // was written by Howard Hinnant.
  22 //
  23 // These test were later refactored grouping
  24 // and porting them to Boost.Move.
  25 //
  26 // Many thanks to Howard for releasing his C++03
  27 // unique_ptr implementation with such detailed
  28 // test cases.
  29 //
  30 //////////////////////////////////////////////
  31
  32 #include "unique_ptr_test_utils_beg.hpp"
  33
  34 namespace bml = ::boost::movelib;
  35
  36 ////////////////////////////////
  37 //   unique_ptr_observers_dereference
  38 ////////////////////////////////
  39
  40 namespace unique_ptr_observers_dereference{
  41
  42 void test()
  43 {
  44    //Single unique_ptr
  45    {
  46    bml::unique_ptr<int> p(new int(3));
  47    BOOST_TEST(*p == 3);
  48    }
  49    //Unbounded array unique_ptr
  50    {
  51    int *pi = new int[2];
  52    pi[0] = 3;
  53    pi[1] = 4;
  54    bml::unique_ptr<int[]> p(pi);
  55    BOOST_TEST(p[0] == 3);
  56    BOOST_TEST(p[1] == 4);
  57    }
  58    //Bounded array unique_ptr
  59    {
  60    int *pi = new int[2];
  61    pi[0] = 3;
  62    pi[1] = 4;
  63    bml::unique_ptr<int[2]> p(pi);
  64    BOOST_TEST(p[0] == 3);
  65    BOOST_TEST(p[1] == 4);
  66    }
  67 }
  68
  69 }  //namespace unique_ptr_observers_dereference{
  70
  71 ////////////////////////////////
  72 //   unique_ptr_observers_dereference
  73 ////////////////////////////////
  74
  75 namespace unique_ptr_observers_explicit_bool{
  76
  77 void test()
  78 {
  79    //Single unique_ptr
  80    {
  81    bml::unique_ptr<int> p(new int(3));
  82    if (p)
  83       ;
  84    else
  85       BOOST_TEST(false);
  86    if (!p)
  87       BOOST_TEST(false);
  88    }
  89    {
  90    bml::unique_ptr<int> p;
  91    if (!p)
  92       ;
  93    else
  94       BOOST_TEST(false);
  95    if (p)
  96       BOOST_TEST(false);
  97    }
  98    //Unbounded array unique_ptr
  99    {
 100    bml::unique_ptr<int[]> p(new int[2]);
 101    if (p)
 102       ;
 103    else
 104       BOOST_TEST(false);
 105    if (!p)
 106       BOOST_TEST(false);
 107    }
 108    {
 109    bml::unique_ptr<int[]> p;
 110    if (!p)
 111       ;
 112    else
 113       BOOST_TEST(false);
 114    if (p)
 115       BOOST_TEST(false);
 116    }
 117    //Bounded array unique_ptr
 118    {
 119    bml::unique_ptr<int[2]> p(new int[2]);
 120    if (p)
 121       ;
 122    else
 123       BOOST_TEST(false);
 124    if (!p)
 125       BOOST_TEST(false);
 126    }
 127    {
 128    bml::unique_ptr<int[2]> p;
 129    if (!p)
 130       ;
 131    else
 132       BOOST_TEST(false);
 133    if (p)
 134       BOOST_TEST(false);
 135    }
 136 }
 137
 138 }  //namespace unique_ptr_observers_explicit_bool{
 139
 140 ////////////////////////////////
 141 //   unique_ptr_observers_get
 142 ////////////////////////////////
 143
 144 namespace unique_ptr_observers_get{
 145
 146 void test()
 147 {
 148    //Single unique_ptr
 149    {
 150    int* p = new int;
 151    bml::unique_ptr<int> s(p);
 152    BOOST_TEST(s.get() == p);
 153    }
 154    //Unbounded array unique_ptr
 155    {
 156    int* p = new int[2];
 157    bml::unique_ptr<int[]> s(p);
 158    BOOST_TEST(s.get() == p);
 159    }
 160    {
 161    int* p = new int[2];
 162    bml::unique_ptr<int[2]> s(p);
 163    BOOST_TEST(s.get() == p);
 164    }
 165    //Bounded array unique_ptr
 166    {
 167    int *pi = new int[2];
 168    pi[0] = 3;
 169    pi[1] = 4;
 170    bml::unique_ptr<int[2]> p(pi);
 171    BOOST_TEST(p[0] == 3);
 172    BOOST_TEST(p[1] == 4);
 173    }
 174 }
 175
 176 }  //namespace unique_ptr_observers_get{
 177
 178 ////////////////////////////////
 179 //   unique_ptr_observers_get_deleter
 180 ////////////////////////////////
 181
 182 namespace unique_ptr_observers_get_deleter{
 183
 184 struct Deleter
 185 {
 186    void operator()(void*) {}
 187
 188    int test() {return 5;}
 189    int test() const {return 6;}
 190 };
 191
 192 void test()
 193 {
 194    //Single unique_ptr
 195    {
 196    bml::unique_ptr<int, Deleter> p;
 197    BOOST_TEST(p.get_deleter().test() == 5);
 198    }
 199    {
 200    const bml::unique_ptr<int, Deleter> p;
 201    BOOST_TEST(p.get_deleter().test() == 6);
 202    }
 203    //Unbounded array unique_ptr
 204    {
 205    bml::unique_ptr<int[], Deleter> p;
 206    BOOST_TEST(p.get_deleter().test() == 5);
 207    }
 208    {
 209    const bml::unique_ptr<int[], Deleter> p;
 210    BOOST_TEST(p.get_deleter().test() == 6);
 211    }
 212    //Bounded array unique_ptr
 213    {
 214    bml::unique_ptr<int[2], Deleter> p;
 215    BOOST_TEST(p.get_deleter().test() == 5);
 216    }
 217    {
 218    const bml::unique_ptr<int[2], Deleter> p;
 219    BOOST_TEST(p.get_deleter().test() == 6);
 220    }
 221 }
 222
 223 }  //namespace unique_ptr_observers_get_deleter{
 224
 225 ////////////////////////////////
 226 //   unique_ptr_observers_op_arrow
 227 ////////////////////////////////
 228
 229 namespace unique_ptr_observers_op_arrow{
 230
 231 void test()
 232 {
 233    //Single unique_ptr
 234    {
 235    bml::unique_ptr<A> p(new A);
 236    BOOST_TEST(p->state_ == 999);
 237    }
 238 }
 239
 240 }  //namespace unique_ptr_observers_op_arrow{
 241
 242
 243 namespace unique_ptr_observers_op_index{
 244
 245 void test()
 246 {
 247    //Unbounded array unique_ptr
 248    {
 249    A *pa = new A[2];
 250    //pa[0] is left default constructed
 251    pa[1].set(888);
 252    bml::unique_ptr<A[]> p(pa);
 253    BOOST_TEST(p[0].state_ == 999);
 254    BOOST_TEST(p[1].state_ == 888);
 255    }
 256    //Bounded array unique_ptr
 257    {
 258    A *pa = new A[2];
 259    //pa[0] is left default constructed
 260    pa[1].set(888);
 261    bml::unique_ptr<A[2]> p(pa);
 262    BOOST_TEST(p[0].state_ == 999);
 263    BOOST_TEST(p[1].state_ == 888);
 264    }
 265 }
 266
 267 }  //namespace unique_ptr_observers_op_index{
 268
 269 ////////////////////////////////
 270 //             main
 271 ////////////////////////////////
 272 int main()
 273 {
 274    //Observers
 275    unique_ptr_observers_dereference::test();
 276    unique_ptr_observers_explicit_bool::test();
 277    unique_ptr_observers_get::test();
 278    unique_ptr_observers_get_deleter::test();
 279    unique_ptr_observers_op_arrow::test();
 280    unique_ptr_observers_op_index::test();
 281
 282    //Test results
 283    return boost::report_errors();
 284
 285 }
 286
 287 #include "unique_ptr_test_utils_end.hpp"