libs/move/test/unique_ptr_nullptr.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_zero
  38 ////////////////////////////////
  39 namespace unique_ptr_zero {
  40
  41 // test initialization/assignment from zero
  42
  43 void test()
  44 {
  45    //Single unique_ptr
  46    reset_counters();
  47    {
  48    bml::unique_ptr<A> s2(0);
  49    BOOST_TEST(A::count == 0);
  50    }
  51    BOOST_TEST(A::count == 0);
  52    {
  53    bml::unique_ptr<A> s2(new A);
  54    BOOST_TEST(A::count == 1);
  55    s2 = 0;
  56    BOOST_TEST(A::count == 0);
  57    BOOST_TEST(s2.get() == 0);
  58    }
  59    BOOST_TEST(A::count == 0);
  60
  61    //Unbounded array unique_ptr
  62    {
  63    bml::unique_ptr<A[]> s2(0);
  64    BOOST_TEST(A::count == 0);
  65    }
  66    BOOST_TEST(A::count == 0);
  67    {
  68    bml::unique_ptr<A[]> s2(new A[2]);
  69    BOOST_TEST(A::count == 2);
  70    s2 = 0;
  71    BOOST_TEST(A::count == 0);
  72    BOOST_TEST(s2.get() == 0);
  73    }
  74    BOOST_TEST(A::count == 0);
  75
  76    //Bounded array unique_ptr
  77    {
  78    bml::unique_ptr<A[2]> s2(0);
  79    BOOST_TEST(A::count == 0);
  80    }
  81    BOOST_TEST(A::count == 0);
  82    {
  83    bml::unique_ptr<A[2]> s2(new A[2]);
  84    BOOST_TEST(A::count == 2);
  85    s2 = 0;
  86    BOOST_TEST(A::count == 0);
  87    BOOST_TEST(s2.get() == 0);
  88    }
  89    BOOST_TEST(A::count == 0);
  90 }
  91
  92 }  //namespace unique_ptr_zero {
  93
  94
  95 ////////////////////////////////
  96 //       unique_ptr_nullptr
  97 ////////////////////////////////
  98
  99 namespace unique_ptr_nullptr{
 100
 101 void test()
 102 {
 103    #if !defined(BOOST_NO_CXX11_NULLPTR)
 104    //Single unique_ptr
 105    reset_counters();
 106    {
 107       bml::unique_ptr<A> p(new A);
 108       BOOST_TEST(A::count == 1);
 109       A* i = p.get();
 110       (void)i;
 111       p.reset(nullptr);
 112       BOOST_TEST(A::count == 0);
 113       BOOST_TEST(p.get() == 0);
 114    }
 115    BOOST_TEST(A::count == 0);
 116    {
 117       bml::unique_ptr<A> p(new A);
 118       BOOST_TEST(A::count == 1);
 119       A* i = p.get();
 120       (void)i;
 121       p = nullptr;
 122       BOOST_TEST(A::count == 0);
 123       BOOST_TEST(p.get() == 0);
 124    }
 125    BOOST_TEST(A::count == 0);
 126
 127    {
 128       bml::unique_ptr<A> pi(nullptr);
 129       BOOST_TEST(pi.get() == nullptr);
 130       BOOST_TEST(pi.get() == 0);
 131    }
 132    BOOST_TEST(A::count == 0);
 133    {
 134       bml::unique_ptr<A> pi(nullptr, bml::unique_ptr<A>::deleter_type());
 135       BOOST_TEST(pi.get() == nullptr);
 136       BOOST_TEST(pi.get() == 0);
 137    }
 138    BOOST_TEST(A::count == 0);
 139
 140    //Unbounded array unique_ptr
 141    reset_counters();
 142    {
 143       bml::unique_ptr<A[]> p(new A[2]);
 144       BOOST_TEST(A::count == 2);
 145       A* i = p.get();
 146       (void)i;
 147       p.reset(nullptr);
 148       BOOST_TEST(A::count == 0);
 149       BOOST_TEST(p.get() == 0);
 150    }
 151    BOOST_TEST(A::count == 0);
 152    {
 153       bml::unique_ptr<A[]> p(new A[2]);
 154       BOOST_TEST(A::count == 2);
 155       A* i = p.get();
 156       (void)i;
 157       p = nullptr;
 158       BOOST_TEST(A::count == 0);
 159       BOOST_TEST(p.get() == 0);
 160    }
 161    BOOST_TEST(A::count == 0);
 162    {
 163       bml::unique_ptr<A[]> pi(nullptr);
 164       BOOST_TEST(pi.get() == nullptr);
 165       BOOST_TEST(pi.get() == 0);
 166    }
 167    BOOST_TEST(A::count == 0);
 168    {
 169       bml::unique_ptr<A[]> pi(nullptr, bml::unique_ptr<A[]>::deleter_type());
 170       BOOST_TEST(pi.get() == nullptr);
 171       BOOST_TEST(pi.get() == 0);
 172    }
 173    BOOST_TEST(A::count == 0);
 174
 175    //Bounded array unique_ptr
 176    reset_counters();
 177    {
 178       bml::unique_ptr<A[2]> p(new A[2]);
 179       BOOST_TEST(A::count == 2);
 180       A* i = p.get();
 181       (void)i;
 182       p.reset(nullptr);
 183       BOOST_TEST(A::count == 0);
 184       BOOST_TEST(p.get() == 0);
 185    }
 186    BOOST_TEST(A::count == 0);
 187    {
 188       bml::unique_ptr<A[2]> p(new A[2]);
 189       BOOST_TEST(A::count == 2);
 190       A* i = p.get();
 191       (void)i;
 192       p = nullptr;
 193       BOOST_TEST(A::count == 0);
 194       BOOST_TEST(p.get() == 0);
 195    }
 196    BOOST_TEST(A::count == 0);
 197    {
 198       bml::unique_ptr<A[2]> pi(nullptr);
 199       BOOST_TEST(pi.get() == nullptr);
 200       BOOST_TEST(pi.get() == 0);
 201    }
 202    BOOST_TEST(A::count == 0);
 203    {
 204       bml::unique_ptr<A[2]> pi(nullptr, bml::unique_ptr<A[2]>::deleter_type());
 205       BOOST_TEST(pi.get() == nullptr);
 206       BOOST_TEST(pi.get() == 0);
 207    }
 208    BOOST_TEST(A::count == 0);
 209    #endif
 210 }
 211
 212 }  //namespace unique_ptr_nullptr{
 213
 214 ////////////////////////////////
 215 //             main
 216 ////////////////////////////////
 217 int main()
 218 {
 219    //nullptr
 220    unique_ptr_zero::test();
 221    unique_ptr_nullptr::test();
 222
 223    //Test results
 224    return boost::report_errors();
 225
 226 }
 227
 228 #include "unique_ptr_test_utils_end.hpp"