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

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