]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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_observers_dereference | |
38 | //////////////////////////////// | |
39 | ||
40 | namespace unique_ptr_observers_dereference{ | |
41 | ||
42 | void test() | |
43 | { | |
44 | //Single unique_ptr | |
45 | { | |
46 | bml::unique_ptr<int> p(new int(3)); | |
47 | BOOST_TEST(*p == 3); | |
48 | } | |
49 | //Unbounded array unique_ptr | |
50 | { | |
51 | int *pi = new int[2]; | |
52 | pi[0] = 3; | |
53 | pi[1] = 4; | |
54 | bml::unique_ptr<int[]> p(pi); | |
55 | BOOST_TEST(p[0] == 3); | |
56 | BOOST_TEST(p[1] == 4); | |
57 | } | |
58 | //Bounded array unique_ptr | |
59 | { | |
60 | int *pi = new int[2]; | |
61 | pi[0] = 3; | |
62 | pi[1] = 4; | |
63 | bml::unique_ptr<int[2]> p(pi); | |
64 | BOOST_TEST(p[0] == 3); | |
65 | BOOST_TEST(p[1] == 4); | |
66 | } | |
67 | } | |
68 | ||
69 | } //namespace unique_ptr_observers_dereference{ | |
70 | ||
71 | //////////////////////////////// | |
72 | // unique_ptr_observers_dereference | |
73 | //////////////////////////////// | |
74 | ||
75 | namespace unique_ptr_observers_explicit_bool{ | |
76 | ||
77 | void test() | |
78 | { | |
79 | //Single unique_ptr | |
80 | { | |
81 | bml::unique_ptr<int> p(new int(3)); | |
82 | if (p) | |
83 | ; | |
84 | else | |
85 | BOOST_TEST(false); | |
86 | if (!p) | |
87 | BOOST_TEST(false); | |
88 | } | |
89 | { | |
90 | bml::unique_ptr<int> p; | |
91 | if (!p) | |
92 | ; | |
93 | else | |
94 | BOOST_TEST(false); | |
95 | if (p) | |
96 | BOOST_TEST(false); | |
97 | } | |
98 | //Unbounded array unique_ptr | |
99 | { | |
100 | bml::unique_ptr<int[]> p(new int[2]); | |
101 | if (p) | |
102 | ; | |
103 | else | |
104 | BOOST_TEST(false); | |
105 | if (!p) | |
106 | BOOST_TEST(false); | |
107 | } | |
108 | { | |
109 | bml::unique_ptr<int[]> p; | |
110 | if (!p) | |
111 | ; | |
112 | else | |
113 | BOOST_TEST(false); | |
114 | if (p) | |
115 | BOOST_TEST(false); | |
116 | } | |
117 | //Bounded array unique_ptr | |
118 | { | |
119 | bml::unique_ptr<int[2]> p(new int[2]); | |
120 | if (p) | |
121 | ; | |
122 | else | |
123 | BOOST_TEST(false); | |
124 | if (!p) | |
125 | BOOST_TEST(false); | |
126 | } | |
127 | { | |
128 | bml::unique_ptr<int[2]> p; | |
129 | if (!p) | |
130 | ; | |
131 | else | |
132 | BOOST_TEST(false); | |
133 | if (p) | |
134 | BOOST_TEST(false); | |
135 | } | |
136 | } | |
137 | ||
138 | } //namespace unique_ptr_observers_explicit_bool{ | |
139 | ||
140 | //////////////////////////////// | |
141 | // unique_ptr_observers_get | |
142 | //////////////////////////////// | |
143 | ||
144 | namespace unique_ptr_observers_get{ | |
145 | ||
146 | void test() | |
147 | { | |
148 | //Single unique_ptr | |
149 | { | |
150 | int* p = new int; | |
151 | bml::unique_ptr<int> s(p); | |
152 | BOOST_TEST(s.get() == p); | |
153 | } | |
154 | //Unbounded array unique_ptr | |
155 | { | |
156 | int* p = new int[2]; | |
157 | bml::unique_ptr<int[]> s(p); | |
158 | BOOST_TEST(s.get() == p); | |
159 | } | |
160 | { | |
161 | int* p = new int[2]; | |
162 | bml::unique_ptr<int[2]> s(p); | |
163 | BOOST_TEST(s.get() == p); | |
164 | } | |
165 | //Bounded array unique_ptr | |
166 | { | |
167 | int *pi = new int[2]; | |
168 | pi[0] = 3; | |
169 | pi[1] = 4; | |
170 | bml::unique_ptr<int[2]> p(pi); | |
171 | BOOST_TEST(p[0] == 3); | |
172 | BOOST_TEST(p[1] == 4); | |
173 | } | |
174 | } | |
175 | ||
176 | } //namespace unique_ptr_observers_get{ | |
177 | ||
178 | //////////////////////////////// | |
179 | // unique_ptr_observers_get_deleter | |
180 | //////////////////////////////// | |
181 | ||
182 | namespace unique_ptr_observers_get_deleter{ | |
183 | ||
184 | struct Deleter | |
185 | { | |
186 | void operator()(void*) {} | |
187 | ||
188 | int test() {return 5;} | |
189 | int test() const {return 6;} | |
190 | }; | |
191 | ||
192 | void test() | |
193 | { | |
194 | //Single unique_ptr | |
195 | { | |
196 | bml::unique_ptr<int, Deleter> p; | |
197 | BOOST_TEST(p.get_deleter().test() == 5); | |
198 | } | |
199 | { | |
200 | const bml::unique_ptr<int, Deleter> p; | |
201 | BOOST_TEST(p.get_deleter().test() == 6); | |
202 | } | |
203 | //Unbounded array unique_ptr | |
204 | { | |
205 | bml::unique_ptr<int[], Deleter> p; | |
206 | BOOST_TEST(p.get_deleter().test() == 5); | |
207 | } | |
208 | { | |
209 | const bml::unique_ptr<int[], Deleter> p; | |
210 | BOOST_TEST(p.get_deleter().test() == 6); | |
211 | } | |
212 | //Bounded array unique_ptr | |
213 | { | |
214 | bml::unique_ptr<int[2], Deleter> p; | |
215 | BOOST_TEST(p.get_deleter().test() == 5); | |
216 | } | |
217 | { | |
218 | const bml::unique_ptr<int[2], Deleter> p; | |
219 | BOOST_TEST(p.get_deleter().test() == 6); | |
220 | } | |
221 | } | |
222 | ||
223 | } //namespace unique_ptr_observers_get_deleter{ | |
224 | ||
225 | //////////////////////////////// | |
226 | // unique_ptr_observers_op_arrow | |
227 | //////////////////////////////// | |
228 | ||
229 | namespace unique_ptr_observers_op_arrow{ | |
230 | ||
231 | void test() | |
232 | { | |
233 | //Single unique_ptr | |
234 | { | |
235 | bml::unique_ptr<A> p(new A); | |
236 | BOOST_TEST(p->state_ == 999); | |
237 | } | |
238 | } | |
239 | ||
240 | } //namespace unique_ptr_observers_op_arrow{ | |
241 | ||
242 | ||
243 | namespace unique_ptr_observers_op_index{ | |
244 | ||
245 | void test() | |
246 | { | |
247 | //Unbounded array unique_ptr | |
248 | { | |
249 | A *pa = new A[2]; | |
250 | //pa[0] is left default constructed | |
251 | pa[1].set(888); | |
252 | bml::unique_ptr<A[]> p(pa); | |
253 | BOOST_TEST(p[0].state_ == 999); | |
254 | BOOST_TEST(p[1].state_ == 888); | |
255 | } | |
256 | //Bounded array unique_ptr | |
257 | { | |
258 | A *pa = new A[2]; | |
259 | //pa[0] is left default constructed | |
260 | pa[1].set(888); | |
261 | bml::unique_ptr<A[2]> p(pa); | |
262 | BOOST_TEST(p[0].state_ == 999); | |
263 | BOOST_TEST(p[1].state_ == 888); | |
264 | } | |
265 | } | |
266 | ||
267 | } //namespace unique_ptr_observers_op_index{ | |
268 | ||
269 | //////////////////////////////// | |
270 | // main | |
271 | //////////////////////////////// | |
272 | int main() | |
273 | { | |
274 | //Observers | |
275 | unique_ptr_observers_dereference::test(); | |
276 | unique_ptr_observers_explicit_bool::test(); | |
277 | unique_ptr_observers_get::test(); | |
278 | unique_ptr_observers_get_deleter::test(); | |
279 | unique_ptr_observers_op_arrow::test(); | |
280 | unique_ptr_observers_op_index::test(); | |
281 | ||
282 | //Test results | |
283 | return boost::report_errors(); | |
284 | ||
285 | } | |
286 | ||
287 | #include "unique_ptr_test_utils_end.hpp" |