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 | |
33 | namespace bml = ::boost::movelib; |
34 | |
35 | //////////////////////////////// |
36 | // unique_ptr_zero |
37 | //////////////////////////////// |
38 | namespace unique_ptr_zero { |
39 | |
40 | // test initialization/assignment from zero |
41 | |
42 | void 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 | |
98 | namespace unique_ptr_nullptr{ |
99 | |
100 | void 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 | //////////////////////////////// |
216 | int 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 |