ceph/src/boost/libs/move/test/unique_ptr_default_deleter.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/default_delete.hpp>
  14 #include <boost/core/lightweight_test.hpp>
  15
  16 //////////////////////////////////////////////
  17 //
  18 // The initial implementation of these tests
  19 // was written by Howard Hinnant.
  20 //
  21 // These test were later refactored grouping
  22 // and porting them to Boost.Move.
  23 //
  24 // Many thanks to Howard for releasing his C++03
  25 // unique_ptr implementation with such detailed
  26 // test cases.
  27 //
  28 //////////////////////////////////////////////
  29
  30 ////////////////////////////////
  31 //   unique_ptr_dltr_dflt_convert_ctor
  32 ////////////////////////////////
  33
  34 namespace bml = ::boost::movelib;
  35
  36 struct A
  37 {
  38    static int count;
  39    A() {++count;}
  40    A(const A&) {++count;}
  41    virtual ~A() {--count;}
  42 };
  43
  44 int A::count = 0;
  45
  46 struct B
  47    : public A
  48 {
  49    static int count;
  50    B() : A() {++count;}
  51    B(const B&) : A() {++count;}
  52    virtual ~B() {--count;}
  53 };
  54
  55 int B::count = 0;
  56
  57 void reset_counters()
  58 {  A::count = B::count = 0;  }
  59
  60 namespace unique_ptr_dltr_dflt_convert_ctor{
  61
  62 void test()
  63 {
  64    //Single element deleter
  65    {
  66    reset_counters();
  67    bml::default_delete<B> d2;
  68    bml::default_delete<A> d1 = d2;
  69    A* p = new B;
  70    BOOST_TEST(A::count == 1);
  71    BOOST_TEST(B::count == 1);
  72    d1(p);
  73    BOOST_TEST(A::count == 0);
  74    BOOST_TEST(B::count == 0);
  75    }
  76    //Array element deleter
  77    {
  78    reset_counters();
  79    bml::default_delete<A[]> d2;
  80    bml::default_delete<const A[]> d1 = d2;
  81    const A* p = new const A[2];
  82    BOOST_TEST(A::count == 2);
  83    d1(p);
  84    BOOST_TEST(A::count == 0);
  85    }
  86    //Bounded array element deleter
  87    {
  88    reset_counters();
  89    bml::default_delete<A[2]> d2;
  90    bml::default_delete<const A[2]> d1 = d2;
  91    const A* p = new const A[2];
  92    BOOST_TEST(A::count == 2);
  93    d1(p);
  94    bml::default_delete<const A[]> d0 = d1;
  95    d0(0);
  96    BOOST_TEST(A::count == 0);
  97    }
  98 }
  99
 100 }  //namespace unique_ptr_dltr_dflt_convert_ctor{
 101
 102 ////////////////////////////////
 103 //   unique_ptr_dltr_dflt_convert_assign
 104 ////////////////////////////////
 105
 106 namespace unique_ptr_dltr_dflt_convert_assign{
 107
 108 void test()
 109 {
 110    //Single element deleter
 111    {
 112    reset_counters();
 113    bml::default_delete<B> d2;
 114    bml::default_delete<A> d1;
 115    d1 = d2;
 116    A* p = new B;
 117    BOOST_TEST(A::count == 1);
 118    BOOST_TEST(B::count == 1);
 119    d1(p);
 120    BOOST_TEST(A::count == 0);
 121    BOOST_TEST(B::count == 0);
 122    }
 123    //Array element deleter
 124    {
 125    reset_counters();
 126    bml::default_delete<A[]> d2;
 127    bml::default_delete<const A[]> d1;
 128    d1 = d2;
 129    const A* p = new const A[2];
 130    BOOST_TEST(A::count == 2);
 131    d1(p);
 132    BOOST_TEST(A::count == 0);
 133    }
 134    //Bounded array element deleter
 135    {
 136    reset_counters();
 137    bml::default_delete<A[2]> d2;
 138    bml::default_delete<const A[2]> d1;
 139    d1 = d2;
 140    const A* p = new const A[2];
 141    BOOST_TEST(A::count == 2);
 142    d1(p);
 143    bml::default_delete<const A[]> d0;
 144    d0 = d1;
 145    d0(0);
 146    BOOST_TEST(A::count == 0);
 147    }
 148 }
 149
 150 }  //namespace unique_ptr_dltr_dflt_convert_assign{
 151
 152
 153 ////////////////////////////////
 154 //   unique_ptr_dltr_dflt_default
 155 ////////////////////////////////
 156
 157 namespace unique_ptr_dltr_dflt_default{
 158
 159 void test()
 160 {
 161    {
 162    //Single element deleter
 163    reset_counters();
 164    bml::default_delete<A> d;
 165    A* p = new A;
 166    BOOST_TEST(A::count == 1);
 167    d(p);
 168    BOOST_TEST(A::count == 0);
 169    }
 170    {
 171    //Array element deleter
 172    reset_counters();
 173    bml::default_delete<A[]> d;
 174    A* p = new A[2];
 175    BOOST_TEST(A::count == 2);
 176    d(p);
 177    BOOST_TEST(A::count == 0);
 178    }
 179
 180    {
 181    //Bounded Array element deleter
 182    reset_counters();
 183    bml::default_delete<A[10]> d;
 184    A* p = new A[10];
 185    BOOST_TEST(A::count == 10);
 186    d(p);
 187    BOOST_TEST(A::count == 0);
 188    }
 189 }
 190
 191 }  //namespace unique_ptr_dltr_dflt_default{
 192
 193 ////////////////////////////////
 194 //             main
 195 ////////////////////////////////
 196 int main()
 197 {
 198    unique_ptr_dltr_dflt_convert_ctor::test();
 199    unique_ptr_dltr_dflt_convert_assign::test();
 200    unique_ptr_dltr_dflt_default::test();
 201
 202    //Test results
 203    return boost::report_errors();
 204 }