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/core/ignore_unused.hpp> 15 #include <boost/move/unique_ptr.hpp> 16 #include <boost/static_assert.hpp> 17 #include <boost/core/lightweight_test.hpp> 18 19 ////////////////////////////////////////////// 20 // 21 // The initial implementation of these tests 22 // was written by Howard Hinnant. 23 // 24 // These test were later refactored grouping 25 // and porting them to Boost.Move. 26 // 27 // Many thanks to Howard for releasing his C++03 28 // unique_ptr implementation with such detailed 29 // test cases. 30 // 31 ////////////////////////////////////////////// 32 33 #include "unique_ptr_test_utils_beg.hpp" 34 35 namespace bml = ::boost::movelib; 36 37 //////////////////////////////// 38 // unique_ptr_zero 39 //////////////////////////////// 40 namespace unique_ptr_zero { 41 42 // test initialization/assignment from zero 43 test()44void test() 45 { 46 //Single unique_ptr 47 reset_counters(); 48 { 49 bml::unique_ptr<A> s2(0); 50 BOOST_TEST(A::count == 0); 51 } 52 BOOST_TEST(A::count == 0); 53 { 54 bml::unique_ptr<A> s2(new A); 55 BOOST_TEST(A::count == 1); 56 s2 = 0; 57 BOOST_TEST(A::count == 0); 58 BOOST_TEST(s2.get() == 0); 59 } 60 BOOST_TEST(A::count == 0); 61 62 //Unbounded array unique_ptr 63 { 64 bml::unique_ptr<A[]> s2(0); 65 BOOST_TEST(A::count == 0); 66 } 67 BOOST_TEST(A::count == 0); 68 { 69 bml::unique_ptr<A[]> s2(new A[2]); 70 BOOST_TEST(A::count == 2); 71 s2 = 0; 72 BOOST_TEST(A::count == 0); 73 BOOST_TEST(s2.get() == 0); 74 } 75 BOOST_TEST(A::count == 0); 76 77 //Bounded array unique_ptr 78 { 79 bml::unique_ptr<A[2]> s2(0); 80 BOOST_TEST(A::count == 0); 81 } 82 BOOST_TEST(A::count == 0); 83 { 84 bml::unique_ptr<A[2]> s2(new A[2]); 85 BOOST_TEST(A::count == 2); 86 s2 = 0; 87 BOOST_TEST(A::count == 0); 88 BOOST_TEST(s2.get() == 0); 89 } 90 BOOST_TEST(A::count == 0); 91 } 92 93 } //namespace unique_ptr_zero { 94 95 96 //////////////////////////////// 97 // unique_ptr_nullptr 98 //////////////////////////////// 99 100 namespace unique_ptr_nullptr{ 101 test()102void test() 103 { 104 #if !defined(BOOST_NO_CXX11_NULLPTR) 105 //Single unique_ptr 106 reset_counters(); 107 { 108 bml::unique_ptr<A> p(new A); 109 BOOST_TEST(A::count == 1); 110 A* i = p.get(); 111 ::boost::ignore_unused(i); 112 p.reset(nullptr); 113 BOOST_TEST(A::count == 0); 114 BOOST_TEST(p.get() == 0); 115 } 116 BOOST_TEST(A::count == 0); 117 { 118 bml::unique_ptr<A> p(new A); 119 BOOST_TEST(A::count == 1); 120 A* i = p.get(); 121 ::boost::ignore_unused(i); 122 p = nullptr; 123 BOOST_TEST(A::count == 0); 124 BOOST_TEST(p.get() == 0); 125 } 126 BOOST_TEST(A::count == 0); 127 128 { 129 bml::unique_ptr<A> pi(nullptr); 130 BOOST_TEST(pi.get() == nullptr); 131 BOOST_TEST(pi.get() == 0); 132 } 133 BOOST_TEST(A::count == 0); 134 { 135 bml::unique_ptr<A> pi(nullptr, bml::unique_ptr<A>::deleter_type()); 136 BOOST_TEST(pi.get() == nullptr); 137 BOOST_TEST(pi.get() == 0); 138 } 139 BOOST_TEST(A::count == 0); 140 141 //Unbounded array unique_ptr 142 reset_counters(); 143 { 144 bml::unique_ptr<A[]> p(new A[2]); 145 BOOST_TEST(A::count == 2); 146 A* i = p.get(); 147 ::boost::ignore_unused(i); 148 p.reset(nullptr); 149 BOOST_TEST(A::count == 0); 150 BOOST_TEST(p.get() == 0); 151 } 152 BOOST_TEST(A::count == 0); 153 { 154 bml::unique_ptr<A[]> p(new A[2]); 155 BOOST_TEST(A::count == 2); 156 A* i = p.get(); 157 ::boost::ignore_unused(i); 158 p = nullptr; 159 BOOST_TEST(A::count == 0); 160 BOOST_TEST(p.get() == 0); 161 } 162 BOOST_TEST(A::count == 0); 163 { 164 bml::unique_ptr<A[]> pi(nullptr); 165 BOOST_TEST(pi.get() == nullptr); 166 BOOST_TEST(pi.get() == 0); 167 } 168 BOOST_TEST(A::count == 0); 169 { 170 bml::unique_ptr<A[]> pi(nullptr, bml::unique_ptr<A[]>::deleter_type()); 171 BOOST_TEST(pi.get() == nullptr); 172 BOOST_TEST(pi.get() == 0); 173 } 174 BOOST_TEST(A::count == 0); 175 176 //Bounded array unique_ptr 177 reset_counters(); 178 { 179 bml::unique_ptr<A[2]> p(new A[2]); 180 BOOST_TEST(A::count == 2); 181 A* i = p.get(); 182 ::boost::ignore_unused(i); 183 p.reset(nullptr); 184 BOOST_TEST(A::count == 0); 185 BOOST_TEST(p.get() == 0); 186 } 187 BOOST_TEST(A::count == 0); 188 { 189 bml::unique_ptr<A[2]> p(new A[2]); 190 BOOST_TEST(A::count == 2); 191 A* i = p.get(); 192 ::boost::ignore_unused(i); 193 p = nullptr; 194 BOOST_TEST(A::count == 0); 195 BOOST_TEST(p.get() == 0); 196 } 197 BOOST_TEST(A::count == 0); 198 { 199 bml::unique_ptr<A[2]> pi(nullptr); 200 BOOST_TEST(pi.get() == nullptr); 201 BOOST_TEST(pi.get() == 0); 202 } 203 BOOST_TEST(A::count == 0); 204 { 205 bml::unique_ptr<A[2]> pi(nullptr, bml::unique_ptr<A[2]>::deleter_type()); 206 BOOST_TEST(pi.get() == nullptr); 207 BOOST_TEST(pi.get() == 0); 208 } 209 BOOST_TEST(A::count == 0); 210 #endif 211 } 212 213 } //namespace unique_ptr_nullptr{ 214 215 //////////////////////////////// 216 // main 217 //////////////////////////////// main()218int main() 219 { 220 //nullptr 221 unique_ptr_zero::test(); 222 unique_ptr_nullptr::test(); 223 224 //Test results 225 return boost::report_errors(); 226 227 } 228 229 #include "unique_ptr_test_utils_end.hpp" 230