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

source code of boost/libs/move/test/unique_ptr_nullptr.cpp