]>
Commit | Line | Data |
---|---|---|
1 | ////////////////////////////////////////////////////////////////////////////// | |
2 | // | |
3 | // (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost | |
4 | // Software License, Version 1.0. (See accompanying file | |
5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
6 | // | |
7 | // See http://www.boost.org/libs/container for documentation. | |
8 | // | |
9 | ////////////////////////////////////////////////////////////////////////////// | |
10 | #include <boost/container/detail/config_begin.hpp> | |
11 | #include <boost/container/scoped_allocator_fwd.hpp> | |
12 | ||
13 | // container/detail | |
14 | #include <boost/container/detail/mpl.hpp> | |
15 | // move | |
16 | #include <boost/move/utility_core.hpp> | |
17 | #include <boost/move/adl_move_swap.hpp> | |
18 | //boost | |
19 | #include <boost/tuple/tuple.hpp> | |
20 | // std | |
21 | #include <memory> | |
22 | #include <cstddef> | |
23 | ||
24 | #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE) | |
25 | #include <tuple> | |
26 | #endif | |
27 | ||
28 | //test | |
29 | #include <boost/core/lightweight_test.hpp> | |
30 | ||
31 | #include "allocator_argument_tester.hpp" | |
32 | ||
33 | template<unsigned int Type> | |
34 | struct tagged_integer | |
35 | {}; | |
36 | ||
37 | struct mark_on_destructor | |
38 | { | |
39 | mark_on_destructor() | |
40 | { | |
41 | destroyed = false; | |
42 | } | |
43 | ||
44 | ~mark_on_destructor() | |
45 | { | |
46 | destroyed = true; | |
47 | } | |
48 | ||
49 | static bool destroyed; | |
50 | }; | |
51 | ||
52 | bool mark_on_destructor::destroyed = false; | |
53 | ||
54 | #include <boost/container/scoped_allocator.hpp> | |
55 | #include <boost/static_assert.hpp> | |
56 | #include <boost/container/vector.hpp> | |
57 | #include <boost/container/detail/pair.hpp> | |
58 | ||
59 | int main() | |
60 | { | |
61 | using namespace boost::container; | |
62 | ||
63 | typedef propagation_test_allocator<tagged_integer<0>, 0> OuterAlloc; | |
64 | typedef propagation_test_allocator<tagged_integer<0>, 10> Outer10IdAlloc; | |
65 | typedef propagation_test_allocator<tagged_integer<9>, 0> Rebound9OuterAlloc; | |
66 | typedef propagation_test_allocator<tagged_integer<1>, 1> InnerAlloc1; | |
67 | typedef propagation_test_allocator<tagged_integer<2>, 2> InnerAlloc2; | |
68 | typedef propagation_test_allocator<tagged_integer<1>, 11> Inner11IdAlloc1; | |
69 | ||
70 | typedef propagation_test_allocator<tagged_integer<0>, 0, false> OuterAllocFalseHasTrueTypes; | |
71 | typedef propagation_test_allocator<tagged_integer<0>, 0, true> OuterAllocTrueHasTrueTypes; | |
72 | typedef propagation_test_allocator<tagged_integer<1>, 1, false> InnerAlloc1FalseHasTrueTypes; | |
73 | typedef propagation_test_allocator<tagged_integer<1>, 1, true> InnerAlloc1TrueHasTrueTypes; | |
74 | typedef propagation_test_allocator<tagged_integer<2>, 2, false> InnerAlloc2FalseHasTrueTypes; | |
75 | typedef propagation_test_allocator<tagged_integer<2>, 2, true> InnerAlloc2TrueHasTrueTypes; | |
76 | ||
77 | // | |
78 | typedef scoped_allocator_adaptor< OuterAlloc > Scoped0Inner; | |
79 | typedef scoped_allocator_adaptor< OuterAlloc | |
80 | , InnerAlloc1 > Scoped1Inner; | |
81 | typedef scoped_allocator_adaptor< OuterAlloc | |
82 | , InnerAlloc1 | |
83 | , InnerAlloc2 > Scoped2Inner; | |
84 | typedef scoped_allocator_adaptor | |
85 | < scoped_allocator_adaptor | |
86 | <Outer10IdAlloc> | |
87 | > ScopedScoped0Inner; | |
88 | typedef scoped_allocator_adaptor | |
89 | < scoped_allocator_adaptor | |
90 | <Outer10IdAlloc, Inner11IdAlloc1> | |
91 | , InnerAlloc1 | |
92 | > ScopedScoped1Inner; | |
93 | typedef scoped_allocator_adaptor< Rebound9OuterAlloc > Rebound9Scoped0Inner; | |
94 | typedef scoped_allocator_adaptor< Rebound9OuterAlloc | |
95 | , InnerAlloc1 > Rebound9Scoped1Inner; | |
96 | typedef scoped_allocator_adaptor< Rebound9OuterAlloc | |
97 | , InnerAlloc1 | |
98 | , InnerAlloc2 > Rebound9Scoped2Inner; | |
99 | ||
100 | //outer_allocator_type | |
101 | BOOST_STATIC_ASSERT(( container_detail::is_same< OuterAlloc | |
102 | , Scoped0Inner::outer_allocator_type>::value )); | |
103 | BOOST_STATIC_ASSERT(( container_detail::is_same< OuterAlloc | |
104 | , Scoped1Inner::outer_allocator_type>::value )); | |
105 | BOOST_STATIC_ASSERT(( container_detail::is_same< OuterAlloc | |
106 | , Scoped2Inner::outer_allocator_type>::value )); | |
107 | //value_type | |
108 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::value_type | |
109 | , Scoped0Inner::value_type>::value )); | |
110 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::value_type | |
111 | , Scoped1Inner::value_type>::value )); | |
112 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::value_type | |
113 | , Scoped2Inner::value_type>::value )); | |
114 | //size_type | |
115 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::size_type | |
116 | , Scoped0Inner::size_type>::value )); | |
117 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::size_type | |
118 | , Scoped1Inner::size_type>::value )); | |
119 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::size_type | |
120 | , Scoped2Inner::size_type>::value )); | |
121 | ||
122 | //difference_type | |
123 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::difference_type | |
124 | , Scoped0Inner::difference_type>::value )); | |
125 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::difference_type | |
126 | , Scoped1Inner::difference_type>::value )); | |
127 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::difference_type | |
128 | , Scoped2Inner::difference_type>::value )); | |
129 | ||
130 | //pointer | |
131 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::pointer | |
132 | , Scoped0Inner::pointer>::value )); | |
133 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::pointer | |
134 | , Scoped1Inner::pointer>::value )); | |
135 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::pointer | |
136 | , Scoped2Inner::pointer>::value )); | |
137 | ||
138 | //const_pointer | |
139 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_pointer | |
140 | , Scoped0Inner::const_pointer>::value )); | |
141 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_pointer | |
142 | , Scoped1Inner::const_pointer>::value )); | |
143 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_pointer | |
144 | , Scoped2Inner::const_pointer>::value )); | |
145 | ||
146 | //void_pointer | |
147 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::void_pointer | |
148 | , Scoped0Inner::void_pointer>::value )); | |
149 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::void_pointer | |
150 | , Scoped1Inner::void_pointer>::value )); | |
151 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::void_pointer | |
152 | , Scoped2Inner::void_pointer>::value )); | |
153 | ||
154 | //const_void_pointer | |
155 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_void_pointer | |
156 | , Scoped0Inner::const_void_pointer>::value )); | |
157 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_void_pointer | |
158 | , Scoped1Inner::const_void_pointer>::value )); | |
159 | BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_void_pointer | |
160 | , Scoped2Inner::const_void_pointer>::value )); | |
161 | ||
162 | //rebind | |
163 | BOOST_STATIC_ASSERT(( container_detail::is_same<Scoped0Inner::rebind< tagged_integer<9> >::other | |
164 | , Rebound9Scoped0Inner >::value )); | |
165 | BOOST_STATIC_ASSERT(( container_detail::is_same<Scoped1Inner::rebind< tagged_integer<9> >::other | |
166 | , Rebound9Scoped1Inner >::value )); | |
167 | BOOST_STATIC_ASSERT(( container_detail::is_same<Scoped2Inner::rebind< tagged_integer<9> >::other | |
168 | , Rebound9Scoped2Inner >::value )); | |
169 | ||
170 | //inner_allocator_type | |
171 | BOOST_STATIC_ASSERT(( container_detail::is_same< Scoped0Inner | |
172 | , Scoped0Inner::inner_allocator_type>::value )); | |
173 | BOOST_STATIC_ASSERT(( container_detail::is_same< scoped_allocator_adaptor<InnerAlloc1> | |
174 | , Scoped1Inner::inner_allocator_type>::value )); | |
175 | BOOST_STATIC_ASSERT(( container_detail::is_same< scoped_allocator_adaptor<InnerAlloc1, InnerAlloc2> | |
176 | , Scoped2Inner::inner_allocator_type>::value )); | |
177 | ||
178 | { | |
179 | //Propagation test | |
180 | typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes > Scoped0InnerF; | |
181 | typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes > Scoped0InnerT; | |
182 | typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes | |
183 | , InnerAlloc1FalseHasTrueTypes > Scoped1InnerFF; | |
184 | typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes | |
185 | , InnerAlloc1TrueHasTrueTypes > Scoped1InnerFT; | |
186 | typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes | |
187 | , InnerAlloc1FalseHasTrueTypes > Scoped1InnerTF; | |
188 | typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes | |
189 | , InnerAlloc1TrueHasTrueTypes > Scoped1InnerTT; | |
190 | typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes | |
191 | , InnerAlloc1FalseHasTrueTypes | |
192 | , InnerAlloc2FalseHasTrueTypes > Scoped2InnerFFF; | |
193 | typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes | |
194 | , InnerAlloc1FalseHasTrueTypes | |
195 | , InnerAlloc2TrueHasTrueTypes > Scoped2InnerFFT; | |
196 | typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes | |
197 | , InnerAlloc1TrueHasTrueTypes | |
198 | , InnerAlloc2FalseHasTrueTypes > Scoped2InnerFTF; | |
199 | typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes | |
200 | , InnerAlloc1TrueHasTrueTypes | |
201 | , InnerAlloc2TrueHasTrueTypes > Scoped2InnerFTT; | |
202 | typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes | |
203 | , InnerAlloc1FalseHasTrueTypes | |
204 | , InnerAlloc2FalseHasTrueTypes > Scoped2InnerTFF; | |
205 | typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes | |
206 | , InnerAlloc1FalseHasTrueTypes | |
207 | , InnerAlloc2TrueHasTrueTypes > Scoped2InnerTFT; | |
208 | typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes | |
209 | , InnerAlloc1TrueHasTrueTypes | |
210 | , InnerAlloc2FalseHasTrueTypes > Scoped2InnerTTF; | |
211 | typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes | |
212 | , InnerAlloc1TrueHasTrueTypes | |
213 | , InnerAlloc2TrueHasTrueTypes > Scoped2InnerTTT; | |
214 | ||
215 | //propagate_on_container_copy_assignment | |
216 | //0 inner | |
217 | BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_copy_assignment::value )); | |
218 | BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_copy_assignment::value )); | |
219 | //1 inner | |
220 | BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_copy_assignment::value )); | |
221 | BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_copy_assignment::value )); | |
222 | BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_copy_assignment::value )); | |
223 | BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_copy_assignment::value )); | |
224 | //2 inner | |
225 | BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_copy_assignment::value )); | |
226 | BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_copy_assignment::value )); | |
227 | BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_copy_assignment::value )); | |
228 | BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_copy_assignment::value )); | |
229 | BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_copy_assignment::value )); | |
230 | BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_copy_assignment::value )); | |
231 | BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_copy_assignment::value )); | |
232 | BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_copy_assignment::value )); | |
233 | ||
234 | //propagate_on_container_move_assignment | |
235 | //0 inner | |
236 | BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_move_assignment::value )); | |
237 | BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_move_assignment::value )); | |
238 | //1 inner | |
239 | BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_move_assignment::value )); | |
240 | BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_move_assignment::value )); | |
241 | BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_move_assignment::value )); | |
242 | BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_move_assignment::value )); | |
243 | //2 inner | |
244 | BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_move_assignment::value )); | |
245 | BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_move_assignment::value )); | |
246 | BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_move_assignment::value )); | |
247 | BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_move_assignment::value )); | |
248 | BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_move_assignment::value )); | |
249 | BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_move_assignment::value )); | |
250 | BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_move_assignment::value )); | |
251 | BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_move_assignment::value )); | |
252 | ||
253 | //propagate_on_container_swap | |
254 | //0 inner | |
255 | BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_swap::value )); | |
256 | BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_swap::value )); | |
257 | //1 inner | |
258 | BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_swap::value )); | |
259 | BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_swap::value )); | |
260 | BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_swap::value )); | |
261 | BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_swap::value )); | |
262 | //2 inner | |
263 | BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_swap::value )); | |
264 | BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_swap::value )); | |
265 | BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_swap::value )); | |
266 | BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_swap::value )); | |
267 | BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_swap::value )); | |
268 | BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_swap::value )); | |
269 | BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_swap::value )); | |
270 | BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_swap::value )); | |
271 | //is_always_equal | |
272 | //0 inner | |
273 | BOOST_STATIC_ASSERT(( !Scoped0InnerF::is_always_equal::value )); | |
274 | BOOST_STATIC_ASSERT(( Scoped0InnerT::is_always_equal::value )); | |
275 | //1 inner | |
276 | BOOST_STATIC_ASSERT(( !Scoped1InnerFF::is_always_equal::value )); | |
277 | BOOST_STATIC_ASSERT(( !Scoped1InnerFT::is_always_equal::value )); | |
278 | BOOST_STATIC_ASSERT(( !Scoped1InnerTF::is_always_equal::value )); | |
279 | BOOST_STATIC_ASSERT(( Scoped1InnerTT::is_always_equal::value )); | |
280 | //2 inner | |
281 | BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::is_always_equal::value )); | |
282 | BOOST_STATIC_ASSERT(( !Scoped2InnerFFT::is_always_equal::value )); | |
283 | BOOST_STATIC_ASSERT(( !Scoped2InnerFTF::is_always_equal::value )); | |
284 | BOOST_STATIC_ASSERT(( !Scoped2InnerFTT::is_always_equal::value )); | |
285 | BOOST_STATIC_ASSERT(( !Scoped2InnerTFF::is_always_equal::value )); | |
286 | BOOST_STATIC_ASSERT(( !Scoped2InnerTFT::is_always_equal::value )); | |
287 | BOOST_STATIC_ASSERT(( !Scoped2InnerTTF::is_always_equal::value )); | |
288 | BOOST_STATIC_ASSERT(( Scoped2InnerTTT::is_always_equal::value )); | |
289 | } | |
290 | ||
291 | //Default constructor | |
292 | { | |
293 | Scoped0Inner s0i; | |
294 | Scoped1Inner s1i; | |
295 | //Swap | |
296 | { | |
297 | Scoped0Inner s0i2; | |
298 | Scoped1Inner s1i2; | |
299 | boost::adl_move_swap(s0i, s0i2); | |
300 | boost::adl_move_swap(s1i, s1i2); | |
301 | } | |
302 | } | |
303 | ||
304 | //Default constructor | |
305 | { | |
306 | Scoped0Inner s0i; | |
307 | Scoped1Inner s1i; | |
308 | } | |
309 | ||
310 | //Copy constructor/assignment | |
311 | { | |
312 | Scoped0Inner s0i; | |
313 | Scoped1Inner s1i; | |
314 | Scoped2Inner s2i; | |
315 | ||
316 | Scoped0Inner s0i_b(s0i); | |
317 | Scoped1Inner s1i_b(s1i); | |
318 | Scoped2Inner s2i_b(s2i); | |
319 | ||
320 | BOOST_TEST(s0i == s0i_b); | |
321 | BOOST_TEST(s1i == s1i_b); | |
322 | BOOST_TEST(s2i == s2i_b); | |
323 | ||
324 | s0i_b = s0i; | |
325 | s1i_b = s1i; | |
326 | s2i_b = s2i; | |
327 | ||
328 | BOOST_TEST(s0i == s0i_b); | |
329 | BOOST_TEST(s1i == s1i_b); | |
330 | BOOST_TEST(s2i == s2i_b); | |
331 | } | |
332 | ||
333 | //Copy/move constructor/assignment | |
334 | { | |
335 | Scoped0Inner s0i; | |
336 | Scoped1Inner s1i; | |
337 | Scoped2Inner s2i; | |
338 | ||
339 | Scoped0Inner s0i_b(::boost::move(s0i)); | |
340 | Scoped1Inner s1i_b(::boost::move(s1i)); | |
341 | Scoped2Inner s2i_b(::boost::move(s2i)); | |
342 | ||
343 | BOOST_TEST(s0i_b.outer_allocator().m_move_contructed); | |
344 | BOOST_TEST(s1i_b.outer_allocator().m_move_contructed); | |
345 | BOOST_TEST(s2i_b.outer_allocator().m_move_contructed); | |
346 | ||
347 | s0i_b = ::boost::move(s0i); | |
348 | s1i_b = ::boost::move(s1i); | |
349 | s2i_b = ::boost::move(s2i); | |
350 | ||
351 | BOOST_TEST(s0i_b.outer_allocator().m_move_assigned); | |
352 | BOOST_TEST(s1i_b.outer_allocator().m_move_assigned); | |
353 | BOOST_TEST(s2i_b.outer_allocator().m_move_assigned); | |
354 | } | |
355 | ||
356 | //inner_allocator() | |
357 | { | |
358 | Scoped0Inner s0i; | |
359 | Scoped1Inner s1i; | |
360 | Scoped2Inner s2i; | |
361 | const Scoped0Inner const_s0i; | |
362 | const Scoped1Inner const_s1i; | |
363 | const Scoped2Inner const_s2i; | |
364 | ||
365 | Scoped0Inner::inner_allocator_type &s0i_inner = s0i.inner_allocator(); | |
366 | (void)s0i_inner; | |
367 | const Scoped0Inner::inner_allocator_type &const_s0i_inner = const_s0i.inner_allocator(); | |
368 | (void)const_s0i_inner; | |
369 | Scoped1Inner::inner_allocator_type &s1i_inner = s1i.inner_allocator(); | |
370 | (void)s1i_inner; | |
371 | const Scoped1Inner::inner_allocator_type &const_s1i_inner = const_s1i.inner_allocator(); | |
372 | (void)const_s1i_inner; | |
373 | Scoped2Inner::inner_allocator_type &s2i_inner = s2i.inner_allocator(); | |
374 | (void)s2i_inner; | |
375 | const Scoped2Inner::inner_allocator_type &const_s2i_inner = const_s2i.inner_allocator(); | |
376 | (void)const_s2i_inner; | |
377 | } | |
378 | ||
379 | //operator==/!= | |
380 | { | |
381 | const Scoped0Inner const_s0i; | |
382 | const Rebound9Scoped0Inner const_rs0i; | |
383 | ||
384 | BOOST_TEST(const_s0i == const_s0i); | |
385 | BOOST_TEST(const_rs0i == const_s0i); | |
386 | BOOST_TEST(const_s0i == const_s0i); | |
387 | BOOST_TEST(const_s0i == const_rs0i); | |
388 | ||
389 | const Scoped1Inner const_s1i; | |
390 | const Rebound9Scoped1Inner const_rs1i; | |
391 | ||
392 | BOOST_TEST(const_s1i == const_s1i); | |
393 | BOOST_TEST(const_rs1i == const_s1i); | |
394 | ||
395 | BOOST_TEST(const_s1i == const_s1i); | |
396 | BOOST_TEST(const_s1i == const_rs1i); | |
397 | ||
398 | const Scoped2Inner const_s2i; | |
399 | const Rebound9Scoped2Inner const_rs2i; | |
400 | ||
401 | BOOST_TEST(const_s2i == const_s2i); | |
402 | BOOST_TEST(const_s2i == const_rs2i); | |
403 | ||
404 | BOOST_TEST(const_s2i == const_s2i); | |
405 | BOOST_TEST(const_s2i == const_rs2i); | |
406 | } | |
407 | ||
408 | //outer_allocator() | |
409 | { | |
410 | Scoped0Inner s0i; | |
411 | Scoped1Inner s1i; | |
412 | Scoped2Inner s2i; | |
413 | const Scoped0Inner const_s0i; | |
414 | const Scoped1Inner const_s1i; | |
415 | const Scoped2Inner const_s2i; | |
416 | ||
417 | Scoped0Inner::outer_allocator_type &s0i_inner = s0i.outer_allocator(); | |
418 | (void)s0i_inner; | |
419 | const Scoped0Inner::outer_allocator_type &const_s0i_inner = const_s0i.outer_allocator(); | |
420 | (void)const_s0i_inner; | |
421 | Scoped1Inner::outer_allocator_type &s1i_inner = s1i.outer_allocator(); | |
422 | (void)s1i_inner; | |
423 | const Scoped1Inner::outer_allocator_type &const_s1i_inner = const_s1i.outer_allocator(); | |
424 | (void)const_s1i_inner; | |
425 | Scoped2Inner::outer_allocator_type &s2i_inner = s2i.outer_allocator(); | |
426 | (void)s2i_inner; | |
427 | const Scoped2Inner::outer_allocator_type &const_s2i_inner = const_s2i.outer_allocator(); | |
428 | (void)const_s2i_inner; | |
429 | } | |
430 | ||
431 | //max_size() | |
432 | { | |
433 | const Scoped0Inner const_s0i; | |
434 | const Scoped1Inner const_s1i; | |
435 | const Scoped2Inner const_s2i; | |
436 | const OuterAlloc const_oa; | |
437 | const InnerAlloc1 const_ia1; | |
438 | const InnerAlloc2 const_ia2; | |
439 | ||
440 | BOOST_TEST(const_s0i.max_size() == const_oa.max_size()); | |
441 | BOOST_TEST(const_s1i.max_size() == const_oa.max_size()); | |
442 | ||
443 | BOOST_TEST(const_s2i.max_size() == const_oa.max_size()); | |
444 | BOOST_TEST(const_s1i.inner_allocator().max_size() == const_ia1.max_size()); | |
445 | BOOST_TEST(const_s2i.inner_allocator().inner_allocator().max_size() == const_ia2.max_size()); | |
446 | } | |
447 | //Copy and move operations | |
448 | { | |
449 | //Construction | |
450 | { | |
451 | Scoped0Inner s0i_a, s0i_b(s0i_a), s0i_c(::boost::move(s0i_b)); | |
452 | Scoped1Inner s1i_a, s1i_b(s1i_a), s1i_c(::boost::move(s1i_b)); | |
453 | Scoped2Inner s2i_a, s2i_b(s2i_a), s2i_c(::boost::move(s2i_b)); | |
454 | } | |
455 | //Assignment | |
456 | { | |
457 | Scoped0Inner s0i_a, s0i_b; | |
458 | s0i_a = s0i_b; | |
459 | s0i_a = ::boost::move(s0i_b); | |
460 | Scoped1Inner s1i_a, s1i_b; | |
461 | s1i_a = s1i_b; | |
462 | s1i_a = ::boost::move(s1i_b); | |
463 | Scoped2Inner s2i_a, s2i_b; | |
464 | s2i_a = s2i_b; | |
465 | s2i_a = ::boost::move(s2i_b); | |
466 | } | |
467 | ||
468 | OuterAlloc oa; | |
469 | InnerAlloc1 ia1; | |
470 | InnerAlloc2 ia2; | |
471 | Rebound9OuterAlloc roa; | |
472 | Rebound9Scoped0Inner rs0i; | |
473 | Rebound9Scoped1Inner rs1i; | |
474 | Rebound9Scoped2Inner rs2i; | |
475 | ||
476 | //Copy from outer | |
477 | { | |
478 | Scoped0Inner s0i(oa); | |
479 | Scoped1Inner s1i(oa, ia1); | |
480 | Scoped2Inner s2i(oa, ia1, ia2); | |
481 | } | |
482 | //Move from outer | |
483 | { | |
484 | Scoped0Inner s0i(::boost::move(oa)); | |
485 | Scoped1Inner s1i(::boost::move(oa), ia1); | |
486 | Scoped2Inner s2i(::boost::move(oa), ia1, ia2); | |
487 | } | |
488 | //Copy from rebound outer | |
489 | { | |
490 | Scoped0Inner s0i(roa); | |
491 | Scoped1Inner s1i(roa, ia1); | |
492 | Scoped2Inner s2i(roa, ia1, ia2); | |
493 | } | |
494 | //Move from rebound outer | |
495 | { | |
496 | Scoped0Inner s0i(::boost::move(roa)); | |
497 | Scoped1Inner s1i(::boost::move(roa), ia1); | |
498 | Scoped2Inner s2i(::boost::move(roa), ia1, ia2); | |
499 | } | |
500 | //Copy from rebound scoped | |
501 | { | |
502 | Scoped0Inner s0i(rs0i); | |
503 | Scoped1Inner s1i(rs1i); | |
504 | Scoped2Inner s2i(rs2i); | |
505 | } | |
506 | //Move from rebound scoped | |
507 | { | |
508 | Scoped0Inner s0i(::boost::move(rs0i)); | |
509 | Scoped1Inner s1i(::boost::move(rs1i)); | |
510 | Scoped2Inner s2i(::boost::move(rs2i)); | |
511 | } | |
512 | } | |
513 | ||
514 | { | |
515 | vector<int, scoped_allocator_adaptor< propagation_test_allocator<int, 0> > > dummy; | |
516 | dummy.push_back(0); | |
517 | } | |
518 | ||
519 | //destroy() | |
520 | { | |
521 | { | |
522 | Scoped0Inner s0i; | |
523 | mark_on_destructor mod; | |
524 | s0i.destroy(&mod); | |
525 | BOOST_TEST(mark_on_destructor::destroyed); | |
526 | } | |
527 | ||
528 | { | |
529 | Scoped1Inner s1i; | |
530 | mark_on_destructor mod; | |
531 | s1i.destroy(&mod); | |
532 | BOOST_TEST(mark_on_destructor::destroyed); | |
533 | } | |
534 | { | |
535 | Scoped2Inner s2i; | |
536 | mark_on_destructor mod; | |
537 | s2i.destroy(&mod); | |
538 | BOOST_TEST(mark_on_destructor::destroyed); | |
539 | } | |
540 | } | |
541 | ||
542 | //construct | |
543 | { | |
544 | //////////////////////////////////////////////////////////// | |
545 | //First check scoped allocator with just OuterAlloc. | |
546 | //In this case OuterAlloc (propagation_test_allocator with tag 0) should be | |
547 | //used to construct types. | |
548 | //////////////////////////////////////////////////////////// | |
549 | { | |
550 | Scoped0Inner s0i; | |
551 | //Check construction with 0 user arguments | |
552 | { | |
553 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
554 | MarkType dummy; | |
555 | dummy.~MarkType(); | |
556 | s0i.construct(&dummy); | |
557 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
558 | BOOST_TEST(dummy.value == 0 ); | |
559 | dummy.~MarkType(); | |
560 | } | |
561 | { | |
562 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
563 | MarkType dummy; | |
564 | dummy.~MarkType(); | |
565 | s0i.construct(&dummy); | |
566 | BOOST_TEST(dummy.construction_type == ConstructibleSuffix); | |
567 | BOOST_TEST(dummy.value == 0); | |
568 | dummy.~MarkType(); | |
569 | } | |
570 | { | |
571 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
572 | MarkType dummy; | |
573 | dummy.~MarkType(); | |
574 | s0i.construct(&dummy); | |
575 | BOOST_TEST(dummy.construction_type == ConstructiblePrefix); | |
576 | BOOST_TEST(dummy.value == 0); | |
577 | dummy.~MarkType(); | |
578 | } | |
579 | ||
580 | //Check construction with 1 user arguments | |
581 | { | |
582 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
583 | MarkType dummy; | |
584 | dummy.~MarkType(); | |
585 | s0i.construct(&dummy, 1); | |
586 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
587 | BOOST_TEST(dummy.value == 1); | |
588 | dummy.~MarkType(); | |
589 | } | |
590 | { | |
591 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
592 | MarkType dummy; | |
593 | dummy.~MarkType(); | |
594 | s0i.construct(&dummy, 2); | |
595 | BOOST_TEST(dummy.construction_type == ConstructibleSuffix); | |
596 | BOOST_TEST(dummy.value == 2); | |
597 | dummy.~MarkType(); | |
598 | } | |
599 | { | |
600 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
601 | MarkType dummy; | |
602 | dummy.~MarkType(); | |
603 | s0i.construct(&dummy, 3); | |
604 | BOOST_TEST(dummy.construction_type == ConstructiblePrefix); | |
605 | BOOST_TEST(dummy.value == 3); | |
606 | dummy.~MarkType(); | |
607 | } | |
608 | } | |
609 | //////////////////////////////////////////////////////////// | |
610 | //Then check scoped allocator with OuterAlloc and InnerAlloc. | |
611 | //In this case InnerAlloc (propagation_test_allocator with tag 1) should be | |
612 | //used to construct types. | |
613 | //////////////////////////////////////////////////////////// | |
614 | { | |
615 | Scoped1Inner s1i; | |
616 | //Check construction with 0 user arguments | |
617 | { | |
618 | typedef ::allocator_argument_tester<NotUsesAllocator, 1> MarkType; | |
619 | MarkType dummy; | |
620 | dummy.~MarkType(); | |
621 | s1i.construct(&dummy); | |
622 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
623 | BOOST_TEST(dummy.value == 0); | |
624 | dummy.~MarkType(); | |
625 | } | |
626 | { | |
627 | typedef ::allocator_argument_tester<ConstructibleSuffix, 1> MarkType; | |
628 | MarkType dummy; | |
629 | dummy.~MarkType(); | |
630 | s1i.construct(&dummy); | |
631 | BOOST_TEST(dummy.construction_type == ConstructibleSuffix); | |
632 | BOOST_TEST(dummy.value == 0); | |
633 | dummy.~MarkType(); | |
634 | } | |
635 | { | |
636 | typedef ::allocator_argument_tester<ConstructiblePrefix, 1> MarkType; | |
637 | MarkType dummy; | |
638 | dummy.~MarkType(); | |
639 | s1i.construct(&dummy); | |
640 | BOOST_TEST(dummy.construction_type == ConstructiblePrefix); | |
641 | BOOST_TEST(dummy.value == 0); | |
642 | dummy.~MarkType(); | |
643 | } | |
644 | ||
645 | //Check construction with 1 user arguments | |
646 | { | |
647 | typedef ::allocator_argument_tester<NotUsesAllocator, 1> MarkType; | |
648 | MarkType dummy; | |
649 | dummy.~MarkType(); | |
650 | s1i.construct(&dummy, 1); | |
651 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
652 | BOOST_TEST(dummy.value == 1); | |
653 | dummy.~MarkType(); | |
654 | } | |
655 | { | |
656 | typedef ::allocator_argument_tester<ConstructibleSuffix, 1> MarkType; | |
657 | MarkType dummy; | |
658 | dummy.~MarkType(); | |
659 | s1i.construct(&dummy, 2); | |
660 | BOOST_TEST(dummy.construction_type == ConstructibleSuffix); | |
661 | BOOST_TEST(dummy.value == 2); | |
662 | dummy.~MarkType(); | |
663 | } | |
664 | { | |
665 | typedef ::allocator_argument_tester<ConstructiblePrefix, 1> MarkType; | |
666 | MarkType dummy; | |
667 | dummy.~MarkType(); | |
668 | s1i.construct(&dummy, 3); | |
669 | BOOST_TEST(dummy.construction_type == ConstructiblePrefix); | |
670 | BOOST_TEST(dummy.value == 3); | |
671 | dummy.~MarkType(); | |
672 | } | |
673 | } | |
674 | ||
675 | ////////////////////////////////////////////////////////////////////////////////// | |
676 | //Now test recursive OuterAllocator types (OuterAllocator is a scoped_allocator) | |
677 | ////////////////////////////////////////////////////////////////////////////////// | |
678 | ||
679 | //////////////////////////////////////////////////////////// | |
680 | //First check scoped allocator with just OuterAlloc. | |
681 | //In this case OuterAlloc (propagation_test_allocator with tag 0) should be | |
682 | //used to construct types. | |
683 | //////////////////////////////////////////////////////////// | |
684 | { | |
685 | //Check outer_allocator_type is scoped | |
686 | BOOST_STATIC_ASSERT(( is_scoped_allocator | |
687 | <ScopedScoped0Inner::outer_allocator_type>::value )); | |
688 | BOOST_STATIC_ASSERT(( container_detail::is_same | |
689 | < outermost_allocator<ScopedScoped0Inner>::type | |
690 | , Outer10IdAlloc | |
691 | >::value )); | |
692 | BOOST_STATIC_ASSERT(( container_detail::is_same | |
693 | < ScopedScoped0Inner::outer_allocator_type | |
694 | , scoped_allocator_adaptor<Outer10IdAlloc> | |
695 | >::value )); | |
696 | BOOST_STATIC_ASSERT(( container_detail::is_same | |
697 | < scoped_allocator_adaptor<Outer10IdAlloc>::outer_allocator_type | |
698 | , Outer10IdAlloc | |
699 | >::value )); | |
700 | ScopedScoped0Inner ssro0i; | |
701 | Outer10IdAlloc & val = outermost_allocator<ScopedScoped0Inner>::get(ssro0i); | |
702 | (void)val; | |
703 | //Check construction with 0 user arguments | |
704 | { | |
705 | typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType; | |
706 | MarkType dummy; | |
707 | dummy.~MarkType(); | |
708 | ssro0i.construct(&dummy); | |
709 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
710 | BOOST_TEST(dummy.value == 0); | |
711 | dummy.~MarkType(); | |
712 | } | |
713 | { | |
714 | typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType; | |
715 | MarkType dummy; | |
716 | dummy.~MarkType(); | |
717 | ssro0i.construct(&dummy); | |
718 | BOOST_TEST(dummy.construction_type == ConstructibleSuffix); | |
719 | BOOST_TEST(dummy.value == 0); | |
720 | dummy.~MarkType(); | |
721 | } | |
722 | { | |
723 | typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType; | |
724 | MarkType dummy; | |
725 | dummy.~MarkType(); | |
726 | ssro0i.construct(&dummy); | |
727 | BOOST_TEST(dummy.construction_type == ConstructiblePrefix); | |
728 | BOOST_TEST(dummy.value == 0); | |
729 | dummy.~MarkType(); | |
730 | } | |
731 | ||
732 | //Check construction with 1 user arguments | |
733 | { | |
734 | typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType; | |
735 | MarkType dummy; | |
736 | dummy.~MarkType(); | |
737 | ssro0i.construct(&dummy, 1); | |
738 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
739 | BOOST_TEST(dummy.value == 1); | |
740 | dummy.~MarkType(); | |
741 | } | |
742 | { | |
743 | typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType; | |
744 | MarkType dummy; | |
745 | dummy.~MarkType(); | |
746 | ssro0i.construct(&dummy, 2); | |
747 | BOOST_TEST(dummy.construction_type == ConstructibleSuffix); | |
748 | BOOST_TEST(dummy.value == 2); | |
749 | dummy.~MarkType(); | |
750 | } | |
751 | { | |
752 | typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType; | |
753 | MarkType dummy; | |
754 | dummy.~MarkType(); | |
755 | ssro0i.construct(&dummy, 3); | |
756 | BOOST_TEST(dummy.construction_type == ConstructiblePrefix); | |
757 | BOOST_TEST(dummy.value == 3); | |
758 | dummy.~MarkType(); | |
759 | } | |
760 | } | |
761 | //////////////////////////////////////////////////////////// | |
762 | //Then check scoped allocator with OuterAlloc and InnerAlloc. | |
763 | //In this case inner_allocator_type is not convertible to | |
764 | //::allocator_argument_tester<XXX, 10> so uses_allocator | |
765 | //should be false on all tests. | |
766 | //////////////////////////////////////////////////////////// | |
767 | { | |
768 | //Check outer_allocator_type is scoped | |
769 | BOOST_STATIC_ASSERT(( is_scoped_allocator | |
770 | <ScopedScoped1Inner::outer_allocator_type>::value )); | |
771 | BOOST_STATIC_ASSERT(( container_detail::is_same | |
772 | < outermost_allocator<ScopedScoped1Inner>::type | |
773 | , Outer10IdAlloc | |
774 | >::value )); | |
775 | BOOST_STATIC_ASSERT(( container_detail::is_same | |
776 | < ScopedScoped1Inner::outer_allocator_type | |
777 | , scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1> | |
778 | >::value )); | |
779 | BOOST_STATIC_ASSERT(( container_detail::is_same | |
780 | < scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>::outer_allocator_type | |
781 | , Outer10IdAlloc | |
782 | >::value )); | |
783 | BOOST_STATIC_ASSERT(( ! | |
784 | uses_allocator | |
785 | < ::allocator_argument_tester<ConstructibleSuffix, 10> | |
786 | , ScopedScoped1Inner::inner_allocator_type::outer_allocator_type | |
787 | >::value )); | |
788 | ScopedScoped1Inner ssro1i; | |
789 | Outer10IdAlloc & val = outermost_allocator<ScopedScoped1Inner>::get(ssro1i); | |
790 | (void)val; | |
791 | ||
792 | //Check construction with 0 user arguments | |
793 | { | |
794 | typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType; | |
795 | MarkType dummy; | |
796 | dummy.~MarkType(); | |
797 | ssro1i.construct(&dummy); | |
798 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
799 | BOOST_TEST(dummy.value == 0); | |
800 | dummy.~MarkType(); | |
801 | } | |
802 | { | |
803 | typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType; | |
804 | MarkType dummy; | |
805 | dummy.~MarkType(); | |
806 | ssro1i.construct(&dummy); | |
807 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
808 | BOOST_TEST(dummy.value == 0); | |
809 | dummy.~MarkType(); | |
810 | } | |
811 | { | |
812 | typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType; | |
813 | MarkType dummy; | |
814 | dummy.~MarkType(); | |
815 | ssro1i.construct(&dummy); | |
816 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
817 | BOOST_TEST(dummy.value == 0); | |
818 | dummy.~MarkType(); | |
819 | } | |
820 | ||
821 | //Check construction with 1 user arguments | |
822 | { | |
823 | typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType; | |
824 | MarkType dummy; | |
825 | dummy.~MarkType(); | |
826 | ssro1i.construct(&dummy, 1); | |
827 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
828 | BOOST_TEST(dummy.value == 1); | |
829 | dummy.~MarkType(); | |
830 | } | |
831 | { | |
832 | typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType; | |
833 | MarkType dummy; | |
834 | dummy.~MarkType(); | |
835 | ssro1i.construct(&dummy, 2); | |
836 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
837 | BOOST_TEST(dummy.value == 2); | |
838 | dummy.~MarkType(); | |
839 | } | |
840 | { | |
841 | typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType; | |
842 | MarkType dummy; | |
843 | dummy.~MarkType(); | |
844 | ssro1i.construct(&dummy, 3); | |
845 | BOOST_TEST(dummy.construction_type == NotUsesAllocator); | |
846 | BOOST_TEST(dummy.value == 3); | |
847 | dummy.~MarkType(); | |
848 | } | |
849 | } | |
850 | ||
851 | //////////////////////////////////////////////////////////// | |
852 | //Now check propagation to pair | |
853 | //////////////////////////////////////////////////////////// | |
854 | //First check scoped allocator with just OuterAlloc. | |
855 | //In this case OuterAlloc (propagation_test_allocator with tag 0) should be | |
856 | //used to construct types. | |
857 | //////////////////////////////////////////////////////////// | |
858 | { | |
859 | using container_detail::pair; | |
860 | typedef propagation_test_allocator< pair< tagged_integer<0> | |
861 | , tagged_integer<0> >, 0> OuterPairAlloc; | |
862 | // | |
863 | typedef scoped_allocator_adaptor < OuterPairAlloc > ScopedPair0Inner; | |
864 | ||
865 | ScopedPair0Inner s0i; | |
866 | //Check construction with 0 user arguments | |
867 | { | |
868 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
869 | typedef pair<MarkType, MarkType> MarkTypePair; | |
870 | MarkTypePair dummy; | |
871 | dummy.~MarkTypePair(); | |
872 | s0i.construct(&dummy); | |
873 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
874 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
875 | BOOST_TEST(dummy.first.value == 0); | |
876 | BOOST_TEST(dummy.second.value == 0); | |
877 | dummy.~MarkTypePair(); | |
878 | } | |
879 | { | |
880 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
881 | typedef pair<MarkType, MarkType> MarkTypePair; | |
882 | MarkTypePair dummy; | |
883 | dummy.~MarkTypePair(); | |
884 | s0i.construct(&dummy); | |
885 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
886 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
887 | BOOST_TEST(dummy.first.value == 0); | |
888 | BOOST_TEST(dummy.second.value == 0); | |
889 | dummy.~MarkTypePair(); | |
890 | } | |
891 | { | |
892 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
893 | typedef pair<MarkType, MarkType> MarkTypePair; | |
894 | MarkTypePair dummy; | |
895 | dummy.~MarkTypePair(); | |
896 | s0i.construct(&dummy); | |
897 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
898 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
899 | BOOST_TEST(dummy.first.value == 0); | |
900 | BOOST_TEST(dummy.second.value == 0); | |
901 | dummy.~MarkTypePair(); | |
902 | } | |
903 | #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE) | |
904 | //Check construction with 0 user arguments and Std tuple | |
905 | { | |
906 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
907 | typedef pair<MarkType, MarkType> MarkTypePair; | |
908 | MarkTypePair dummy; | |
909 | dummy.~MarkTypePair(); | |
910 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>()); | |
911 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
912 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
913 | BOOST_TEST(dummy.first.value == 0); | |
914 | BOOST_TEST(dummy.second.value == 0); | |
915 | dummy.~MarkTypePair(); | |
916 | } | |
917 | { | |
918 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
919 | typedef pair<MarkType, MarkType> MarkTypePair; | |
920 | MarkTypePair dummy; | |
921 | dummy.~MarkTypePair(); | |
922 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>()); | |
923 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
924 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
925 | BOOST_TEST(dummy.first.value == 0); | |
926 | BOOST_TEST(dummy.second.value == 0); | |
927 | dummy.~MarkTypePair(); | |
928 | } | |
929 | { | |
930 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
931 | typedef pair<MarkType, MarkType> MarkTypePair; | |
932 | MarkTypePair dummy; | |
933 | dummy.~MarkTypePair(); | |
934 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>()); | |
935 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
936 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
937 | BOOST_TEST(dummy.first.value == 0); | |
938 | BOOST_TEST(dummy.second.value == 0); | |
939 | dummy.~MarkTypePair(); | |
940 | } | |
941 | { | |
942 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
943 | typedef pair<MarkType, MarkType> MarkTypePair; | |
944 | MarkTypePair dummy; | |
945 | dummy.~MarkTypePair(); | |
946 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>()); | |
947 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
948 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
949 | BOOST_TEST(dummy.first.value == 0); | |
950 | BOOST_TEST(dummy.second.value == 0); | |
951 | dummy.~MarkTypePair(); | |
952 | } | |
953 | { | |
954 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
955 | typedef pair<MarkType, MarkType> MarkTypePair; | |
956 | MarkTypePair dummy; | |
957 | dummy.~MarkTypePair(); | |
958 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>()); | |
959 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
960 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
961 | BOOST_TEST(dummy.first.value == 0); | |
962 | BOOST_TEST(dummy.second.value == 0); | |
963 | dummy.~MarkTypePair(); | |
964 | } | |
965 | { | |
966 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
967 | typedef pair<MarkType, MarkType> MarkTypePair; | |
968 | MarkTypePair dummy; | |
969 | dummy.~MarkTypePair(); | |
970 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>()); | |
971 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
972 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
973 | BOOST_TEST(dummy.first.value == 0); | |
974 | BOOST_TEST(dummy.second.value == 0); | |
975 | dummy.~MarkTypePair(); | |
976 | } | |
977 | #endif //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE | |
978 | //Check construction with 1 user arguments for each pair | |
979 | { | |
980 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
981 | typedef pair<MarkType, MarkType> MarkTypePair; | |
982 | MarkTypePair dummy; | |
983 | dummy.~MarkTypePair(); | |
984 | s0i.construct(&dummy, 1, 1); | |
985 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
986 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
987 | BOOST_TEST(dummy.first.value == 1); | |
988 | BOOST_TEST(dummy.second.value == 1); | |
989 | dummy.~MarkTypePair(); | |
990 | } | |
991 | { | |
992 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
993 | typedef pair<MarkType, MarkType> MarkTypePair; | |
994 | MarkTypePair dummy; | |
995 | dummy.~MarkTypePair(); | |
996 | s0i.construct(&dummy, 1, 1); | |
997 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
998 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
999 | BOOST_TEST(dummy.first.value == 1); | |
1000 | BOOST_TEST(dummy.second.value == 1); | |
1001 | dummy.~MarkTypePair(); | |
1002 | } | |
1003 | { | |
1004 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1005 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1006 | MarkTypePair dummy; | |
1007 | dummy.~MarkTypePair(); | |
1008 | s0i.construct(&dummy, 2, 2); | |
1009 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1010 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1011 | BOOST_TEST(dummy.first.value == 2); | |
1012 | BOOST_TEST(dummy.second.value == 2); | |
1013 | dummy.~MarkTypePair(); | |
1014 | } | |
1015 | //Check construction with 1 user arguments for each pair and Boost tuple | |
1016 | { | |
1017 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1018 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1019 | MarkTypePair dummy; | |
1020 | dummy.~MarkTypePair(); | |
1021 | s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<int>(1)); | |
1022 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1023 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1024 | BOOST_TEST(dummy.first.value == 1); | |
1025 | BOOST_TEST(dummy.second.value == 1); | |
1026 | dummy.~MarkTypePair(); | |
1027 | } | |
1028 | { | |
1029 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1030 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1031 | MarkTypePair dummy; | |
1032 | dummy.~MarkTypePair(); | |
1033 | s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<int>(1)); | |
1034 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1035 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1036 | BOOST_TEST(dummy.first.value == 1); | |
1037 | BOOST_TEST(dummy.second.value == 1); | |
1038 | dummy.~MarkTypePair(); | |
1039 | } | |
1040 | { | |
1041 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1042 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1043 | MarkTypePair dummy; | |
1044 | dummy.~MarkTypePair(); | |
1045 | s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(2), boost::tuple<int>(2)); | |
1046 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1047 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1048 | BOOST_TEST(dummy.first.value == 2); | |
1049 | BOOST_TEST(dummy.second.value == 2); | |
1050 | dummy.~MarkTypePair(); | |
1051 | } | |
1052 | #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE) | |
1053 | //Check construction with 1 user arguments for each pair and Boost tuple | |
1054 | { | |
1055 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1056 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1057 | MarkTypePair dummy; | |
1058 | dummy.~MarkTypePair(); | |
1059 | s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<int>(1)); | |
1060 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1061 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1062 | BOOST_TEST(dummy.first.value == 1); | |
1063 | BOOST_TEST(dummy.second.value == 1); | |
1064 | dummy.~MarkTypePair(); | |
1065 | } | |
1066 | { | |
1067 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1068 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1069 | MarkTypePair dummy; | |
1070 | dummy.~MarkTypePair(); | |
1071 | s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<int>(1)); | |
1072 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1073 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1074 | BOOST_TEST(dummy.first.value == 1); | |
1075 | BOOST_TEST(dummy.second.value == 1); | |
1076 | dummy.~MarkTypePair(); | |
1077 | } | |
1078 | { | |
1079 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1080 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1081 | MarkTypePair dummy; | |
1082 | dummy.~MarkTypePair(); | |
1083 | s0i.construct(&dummy, piecewise_construct, std::tuple<int>(2), std::tuple<int>(2)); | |
1084 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1085 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1086 | BOOST_TEST(dummy.first.value == 2); | |
1087 | BOOST_TEST(dummy.second.value == 2); | |
1088 | dummy.~MarkTypePair(); | |
1089 | } | |
1090 | #endif //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE | |
1091 | //Check construction with pair copy construction | |
1092 | { | |
1093 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1094 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1095 | MarkTypePair dummy, dummy2; | |
1096 | dummy.~MarkTypePair(); | |
1097 | s0i.construct(&dummy, dummy2); | |
1098 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1099 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1100 | BOOST_TEST(dummy.first.value == 0); | |
1101 | BOOST_TEST(dummy.second.value == 0); | |
1102 | dummy.~MarkTypePair(); | |
1103 | } | |
1104 | { | |
1105 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1106 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1107 | MarkTypePair dummy, dummy2(1, 1); | |
1108 | dummy.~MarkTypePair(); | |
1109 | s0i.construct(&dummy, dummy2); | |
1110 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1111 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1112 | BOOST_TEST(dummy.first.value == 1); | |
1113 | BOOST_TEST(dummy.second.value == 1); | |
1114 | dummy.~MarkTypePair(); | |
1115 | } | |
1116 | { | |
1117 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1118 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1119 | MarkTypePair dummy, dummy2(2, 2); | |
1120 | dummy.~MarkTypePair(); | |
1121 | s0i.construct(&dummy, dummy2); | |
1122 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1123 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1124 | BOOST_TEST(dummy.first.value == 2); | |
1125 | BOOST_TEST(dummy.second.value == 2); | |
1126 | dummy.~MarkTypePair(); | |
1127 | } | |
1128 | //Check construction with pair move construction | |
1129 | { | |
1130 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1131 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1132 | MarkTypePair dummy, dummy2(3, 3); | |
1133 | dummy2.first.construction_type = dummy2.second.construction_type = ConstructibleSuffix; | |
1134 | dummy.~MarkTypePair(); | |
1135 | s0i.construct(&dummy, ::boost::move(dummy2)); | |
1136 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1137 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1138 | BOOST_TEST(dummy.first.value == 3); | |
1139 | BOOST_TEST(dummy.second.value == 3); | |
1140 | BOOST_TEST(dummy2.first.construction_type == NotUsesAllocator); | |
1141 | BOOST_TEST(dummy2.second.construction_type == NotUsesAllocator); | |
1142 | BOOST_TEST(dummy2.first.value == 0); | |
1143 | BOOST_TEST(dummy2.second.value == 0); | |
1144 | dummy.~MarkTypePair(); | |
1145 | } | |
1146 | { | |
1147 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1148 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1149 | MarkTypePair dummy, dummy2(1, 1); | |
1150 | dummy.~MarkTypePair(); | |
1151 | s0i.construct(&dummy, ::boost::move(dummy2)); | |
1152 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1153 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1154 | BOOST_TEST(dummy.first.value == 1); | |
1155 | BOOST_TEST(dummy.second.value == 1); | |
1156 | BOOST_TEST(dummy2.first.construction_type == ConstructibleSuffix); | |
1157 | BOOST_TEST(dummy2.second.construction_type == ConstructibleSuffix); | |
1158 | BOOST_TEST(dummy2.first.value == 0); | |
1159 | BOOST_TEST(dummy2.second.value == 0); | |
1160 | dummy.~MarkTypePair(); | |
1161 | } | |
1162 | { | |
1163 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1164 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1165 | MarkTypePair dummy, dummy2(2, 2); | |
1166 | dummy.~MarkTypePair(); | |
1167 | s0i.construct(&dummy, ::boost::move(dummy2)); | |
1168 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1169 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1170 | BOOST_TEST(dummy.first.value == 2); | |
1171 | BOOST_TEST(dummy.second.value == 2); | |
1172 | BOOST_TEST(dummy2.first.construction_type == ConstructiblePrefix); | |
1173 | BOOST_TEST(dummy2.second.construction_type == ConstructiblePrefix); | |
1174 | BOOST_TEST(dummy2.first.value == 0); | |
1175 | BOOST_TEST(dummy2.second.value == 0); | |
1176 | dummy.~MarkTypePair(); | |
1177 | } | |
1178 | //Check construction with related pair copy construction | |
1179 | { | |
1180 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1181 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1182 | MarkTypePair dummy; | |
1183 | pair<int, int> dummy2; | |
1184 | dummy.~MarkTypePair(); | |
1185 | s0i.construct(&dummy, dummy2); | |
1186 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1187 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1188 | BOOST_TEST(dummy.first.value == 0); | |
1189 | BOOST_TEST(dummy.second.value == 0); | |
1190 | dummy.~MarkTypePair(); | |
1191 | } | |
1192 | { | |
1193 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1194 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1195 | MarkTypePair dummy; | |
1196 | pair<int, int> dummy2(1, 1); | |
1197 | dummy.~MarkTypePair(); | |
1198 | s0i.construct(&dummy, dummy2); | |
1199 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1200 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1201 | BOOST_TEST(dummy.first.value == 1); | |
1202 | BOOST_TEST(dummy.second.value == 1); | |
1203 | dummy.~MarkTypePair(); | |
1204 | } | |
1205 | { | |
1206 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1207 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1208 | MarkTypePair dummy; | |
1209 | pair<int, int> dummy2(2, 2); | |
1210 | dummy.~MarkTypePair(); | |
1211 | s0i.construct(&dummy, dummy2); | |
1212 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1213 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1214 | BOOST_TEST(dummy.first.value == 2); | |
1215 | BOOST_TEST(dummy.second.value == 2); | |
1216 | dummy.~MarkTypePair(); | |
1217 | } | |
1218 | //Check construction with related pair move construction | |
1219 | { | |
1220 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1221 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1222 | MarkTypePair dummy; | |
1223 | pair<int, int> dummy2(3, 3); | |
1224 | dummy.~MarkTypePair(); | |
1225 | s0i.construct(&dummy, ::boost::move(dummy2)); | |
1226 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1227 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1228 | BOOST_TEST(dummy.first.value == 3); | |
1229 | BOOST_TEST(dummy.second.value == 3); | |
1230 | dummy.~MarkTypePair(); | |
1231 | } | |
1232 | { | |
1233 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1234 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1235 | MarkTypePair dummy; | |
1236 | pair<int, int> dummy2(1, 1); | |
1237 | dummy.~MarkTypePair(); | |
1238 | s0i.construct(&dummy, ::boost::move(dummy2)); | |
1239 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1240 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1241 | BOOST_TEST(dummy.first.value == 1); | |
1242 | BOOST_TEST(dummy.second.value == 1); | |
1243 | dummy.~MarkTypePair(); | |
1244 | } | |
1245 | { | |
1246 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1247 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1248 | MarkTypePair dummy; | |
1249 | pair<int, int> dummy2(2, 2); | |
1250 | dummy.~MarkTypePair(); | |
1251 | s0i.construct(&dummy, ::boost::move(dummy2)); | |
1252 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1253 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1254 | BOOST_TEST(dummy.first.value == 2); | |
1255 | BOOST_TEST(dummy.second.value == 2); | |
1256 | dummy.~MarkTypePair(); | |
1257 | } | |
1258 | //Check construction with 0/1 arguments for each pair and Boost tuple | |
1259 | { | |
1260 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1261 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1262 | MarkTypePair dummy; | |
1263 | dummy.~MarkTypePair(); | |
1264 | s0i.construct(&dummy, piecewise_construct, boost::tuple<>(), boost::tuple<int>(1)); | |
1265 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1266 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1267 | BOOST_TEST(dummy.first.value == 0); | |
1268 | BOOST_TEST(dummy.second.value == 1); | |
1269 | dummy.~MarkTypePair(); | |
1270 | } | |
1271 | { | |
1272 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1273 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1274 | MarkTypePair dummy; | |
1275 | dummy.~MarkTypePair(); | |
1276 | s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<>()); | |
1277 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1278 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1279 | BOOST_TEST(dummy.first.value == 1); | |
1280 | BOOST_TEST(dummy.second.value == 0); | |
1281 | dummy.~MarkTypePair(); | |
1282 | } | |
1283 | { | |
1284 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1285 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1286 | MarkTypePair dummy; | |
1287 | dummy.~MarkTypePair(); | |
1288 | s0i.construct(&dummy, piecewise_construct, boost::tuple<>(), boost::tuple<int>(2)); | |
1289 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1290 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1291 | BOOST_TEST(dummy.first.value == 0); | |
1292 | BOOST_TEST(dummy.second.value == 2); | |
1293 | dummy.~MarkTypePair(); | |
1294 | } | |
1295 | #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE) | |
1296 | //Check construction with 0/1 arguments for each pair and Boost tuple | |
1297 | { | |
1298 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1299 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1300 | MarkTypePair dummy; | |
1301 | dummy.~MarkTypePair(); | |
1302 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<int>(1)); | |
1303 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1304 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1305 | BOOST_TEST(dummy.first.value == 0); | |
1306 | BOOST_TEST(dummy.second.value == 1); | |
1307 | dummy.~MarkTypePair(); | |
1308 | } | |
1309 | { | |
1310 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1311 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1312 | MarkTypePair dummy; | |
1313 | dummy.~MarkTypePair(); | |
1314 | s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<>()); | |
1315 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1316 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1317 | BOOST_TEST(dummy.first.value == 1); | |
1318 | BOOST_TEST(dummy.second.value == 0); | |
1319 | dummy.~MarkTypePair(); | |
1320 | } | |
1321 | { | |
1322 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1323 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1324 | MarkTypePair dummy; | |
1325 | dummy.~MarkTypePair(); | |
1326 | s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<int>(2)); | |
1327 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1328 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1329 | BOOST_TEST(dummy.first.value == 0); | |
1330 | BOOST_TEST(dummy.second.value == 2); | |
1331 | dummy.~MarkTypePair(); | |
1332 | } | |
1333 | #endif //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE | |
1334 | ||
1335 | //Check construction with try_emplace_t 0/1 arguments for each pair | |
1336 | { | |
1337 | typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType; | |
1338 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1339 | MarkTypePair dummy; | |
1340 | dummy.~MarkTypePair(); | |
1341 | s0i.construct(&dummy, try_emplace_t(), 5, 1); | |
1342 | BOOST_TEST(dummy.first.construction_type == NotUsesAllocator); | |
1343 | BOOST_TEST(dummy.second.construction_type == NotUsesAllocator); | |
1344 | BOOST_TEST(dummy.first.value == 5); | |
1345 | BOOST_TEST(dummy.second.value == 1); | |
1346 | dummy.~MarkTypePair(); | |
1347 | } | |
1348 | { | |
1349 | typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType; | |
1350 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1351 | MarkTypePair dummy; | |
1352 | dummy.~MarkTypePair(); | |
1353 | s0i.construct(&dummy, try_emplace_t(), 6); | |
1354 | BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix); | |
1355 | BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix); | |
1356 | BOOST_TEST(dummy.first.value == 6); | |
1357 | BOOST_TEST(dummy.second.value == 0); | |
1358 | dummy.~MarkTypePair(); | |
1359 | } | |
1360 | { | |
1361 | typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType; | |
1362 | typedef pair<MarkType, MarkType> MarkTypePair; | |
1363 | MarkTypePair dummy; | |
1364 | dummy.~MarkTypePair(); | |
1365 | s0i.construct(&dummy, try_emplace_t(), 7, 2); | |
1366 | BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix); | |
1367 | BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix); | |
1368 | BOOST_TEST(dummy.first.value == 7); | |
1369 | BOOST_TEST(dummy.second.value == 2); | |
1370 | dummy.~MarkTypePair(); | |
1371 | } | |
1372 | } | |
1373 | } | |
1374 | ||
1375 | return ::boost::report_errors(); | |
1376 | } | |
1377 | #include <boost/container/detail/config_end.hpp> |