libjmmcg  release_579_6_g8cffd
A C++ library containing an eclectic mix of useful, advanced components.
intrusive.cpp
Go to the documentation of this file.
1 /******************************************************************************
2 ** Copyright © 2011 by J.M.McGuiness, coder@hussar.me.uk
3 **
4 ** This library is free software; you can redistribute it and/or
5 ** modify it under the terms of the GNU Lesser General Public
6 ** License as published by the Free Software Foundation; either
7 ** version 2.1 of the License, or (at your option) any later version.
8 **
9 ** This library is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 ** Lesser General Public License for more details.
13 **
14 ** You should have received a copy of the GNU Lesser General Public
15 ** License along with this library; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18 
19 #include "stdafx.h"
20 
21 #define BOOST_TEST_MODULE libjmmcg_tests
22 #include <boost/test/included/unit_test.hpp>
23 
24 #include "core/intrusive.hpp"
25 
26 using namespace libjmmcg;
27 using namespace ppd;
28 
29 typedef boost::mpl::list<
30  sequential_mode,
31  heavyweight_threading
32 > thread_types;
33 
34 template<class LT>
35 struct data final : public intrusive::node_details_itf<LT>, public sp_counter_type<typename intrusive::node_details_itf<LT>::atomic_ctr_t::value_type, LT> {
36  typedef sp_counter_type<typename intrusive::node_details_itf<LT>::atomic_ctr_t::value_type, LT> base_t;
37  typedef typename base_t::lock_traits lock_traits;
38  typedef typename base_t::atomic_ctr_t atomic_ctr_t;
39  typedef typename base_t::deleter_t deleter_t;
40 
41  const int i;
42 
43  explicit data(int j) noexcept(true)
44  : i(j) {}
45  ~data() noexcept(true) {}
46 
47  tstring
48  to_string() const noexcept(false) {
49  tostringstream os;
50  os<<"i="<<i;
51  return os.str();
52  }
53 };
54 
55 BOOST_AUTO_TEST_SUITE(instrusive)
56 
57 BOOST_AUTO_TEST_SUITE(stack)
58 
59 BOOST_AUTO_TEST_CASE_TEMPLATE(default_ctor, Mdl, thread_types)
60 {
61  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> stack_t;
62 
63  stack_t l;
64  BOOST_CHECK(l.empty());
65  BOOST_CHECK_EQUAL(l.size(), 0U);
66 }
67 
68 BOOST_AUTO_TEST_CASE_TEMPLATE(push_one_item, Mdl, thread_types)
69 {
70  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> stack_t;
71 
72  stack_t l;
73  typename stack_t::value_type val(new typename stack_t::value_type::value_type(1));
74  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 1);
75  l.push(val);
76  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
77  BOOST_CHECK(!l.empty());
78  BOOST_CHECK_EQUAL(l.size(), 1U);
79 }
80 
81 BOOST_AUTO_TEST_CASE_TEMPLATE(push_and_pop_one_item, Mdl, thread_types)
82 {
83  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> stack_t;
84 
85  stack_t l;
86  typename stack_t::value_type val(new typename stack_t::value_type::value_type(1));
87  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 1);
88  l.push(val);
89  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
90  typename stack_t::value_type ret(l.top());
91  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 3);
92  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 3);
93  BOOST_CHECK_EQUAL(val, ret);
94  BOOST_CHECK(!l.empty());
95  BOOST_CHECK_EQUAL(l.size(), 1U);
96  l.pop();
97  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
98  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
99  BOOST_CHECK(l.empty());
100  BOOST_CHECK_EQUAL(l.size(), 0U);
101 }
102 
103 BOOST_AUTO_TEST_CASE_TEMPLATE(push_two_items, Mdl, thread_types)
104 {
105  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> stack_t;
106 
107  stack_t l;
108  typename stack_t::value_type val1(new typename stack_t::value_type::value_type(1));
109  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
110  l.push(val1);
111  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
112  BOOST_CHECK(!l.empty());
113  BOOST_CHECK_EQUAL(l.size(), 1U);
114  typename stack_t::value_type val2(new typename stack_t::value_type::value_type(2));
115  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
116  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
117  l.push(val2);
118  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
119  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
120  BOOST_CHECK(!l.empty());
121  BOOST_CHECK_EQUAL(l.size(), 2U);
122 }
123 
124 BOOST_AUTO_TEST_CASE_TEMPLATE(push_two_items_pop_one1, Mdl, thread_types)
125 {
126  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> stack_t;
127 
128  stack_t l;
129  typename stack_t::value_type val1(new typename stack_t::value_type::value_type(1));
130  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
131  l.push(val1);
132  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
133  typename stack_t::value_type val2(new typename stack_t::value_type::value_type(2));
134  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
135  l.push(val2);
136  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
137  typename stack_t::value_type ret(l.top());
138  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
139  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 3);
140  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 3);
141  BOOST_CHECK_EQUAL(val2, ret);
142  BOOST_CHECK(!l.empty());
143  BOOST_CHECK_EQUAL(l.size(), 2U);
144  l.pop();
145  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
146  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
147  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
148  BOOST_CHECK(!l.empty());
149  BOOST_CHECK_EQUAL(l.size(), 1U);
150 }
151 
152 BOOST_AUTO_TEST_CASE_TEMPLATE(push_two_items_pop_one2, Mdl, thread_types)
153 {
154  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> stack_t;
155 
156  stack_t l;
157  typename stack_t::value_type val1(new typename stack_t::value_type::value_type(1));
158  l.push(val1);
159  typename stack_t::value_type ret(l.top());
160  BOOST_CHECK_EQUAL(val1, ret);
161  BOOST_CHECK(!l.empty());
162  BOOST_CHECK_EQUAL(l.size(), 1U);
163  l.pop();
164  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
165  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
166  BOOST_CHECK(l.empty());
167  BOOST_CHECK_EQUAL(l.size(), 0U);
168  typename stack_t::value_type val2(new typename stack_t::value_type::value_type(2));
169  l.push(val2);
170  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
171  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
172  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
173  BOOST_CHECK(!l.empty());
174  BOOST_CHECK_EQUAL(l.size(), 1U);
175 }
176 
177 BOOST_AUTO_TEST_CASE_TEMPLATE(push_two_items_pop_two, Mdl, thread_types)
178 {
179  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
180 
181  container_t l;
182  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
183  l.push(val1);
184  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
185  l.push(val2);
186  typename container_t::value_type ret2(l.top());
187  BOOST_CHECK_EQUAL(val2, ret2);
188  BOOST_CHECK(!l.empty());
189  BOOST_CHECK_EQUAL(l.size(), 2U);
190  l.pop();
191  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
192  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
193  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
194  BOOST_CHECK(!l.empty());
195  BOOST_CHECK_EQUAL(l.size(), 1U);
196  typename container_t::value_type ret1(l.top());
197  BOOST_CHECK_EQUAL(val1, ret1);
198  BOOST_CHECK(!l.empty());
199  BOOST_CHECK_EQUAL(l.size(), 1U);
200  l.pop();
201  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
202  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
203  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
204  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
205  BOOST_CHECK(l.empty());
206  BOOST_CHECK_EQUAL(l.size(), 0U);
207 }
208 
209 BOOST_AUTO_TEST_CASE_TEMPLATE(push_three_items_pop_three, Mdl, thread_types)
210 {
211  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
212 
213  container_t l;
214  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
215  l.push(val1);
216  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
217  l.push(val2);
218  typename container_t::value_type val3(new typename container_t::value_type::value_type(3));
219  l.push(val3);
220  typename container_t::value_type ret3(l.top());
221  BOOST_CHECK_EQUAL(val3, ret3);
222  BOOST_CHECK(!l.empty());
223  BOOST_CHECK_EQUAL(l.size(), 3U);
224  l.pop();
225  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
226  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
227  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
228  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
229  BOOST_CHECK(!l.empty());
230  BOOST_CHECK_EQUAL(l.size(), 2U);
231  typename container_t::value_type ret2(l.top());
232  BOOST_CHECK_EQUAL(val2, ret2);
233  BOOST_CHECK(!l.empty());
234  BOOST_CHECK_EQUAL(l.size(), 2U);
235  l.pop();
236  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
237  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
238  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
239  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
240  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
241  BOOST_CHECK(!l.empty());
242  BOOST_CHECK_EQUAL(l.size(), 1U);
243  typename container_t::value_type ret1(l.top());
244  BOOST_CHECK_EQUAL(val1, ret1);
245  BOOST_CHECK(!l.empty());
246  BOOST_CHECK_EQUAL(l.size(), 1U);
247  l.pop();
248  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
249  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
250  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
251  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
252  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
253  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
254  BOOST_CHECK(l.empty());
255  BOOST_CHECK_EQUAL(l.size(), 0U);
256 }
257 
258 BOOST_AUTO_TEST_CASE_TEMPLATE(empty_begin_is_end, Mdl, thread_types)
259 {
260  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
261 
262  container_t l;
263  BOOST_CHECK(l.empty());
264  BOOST_CHECK_EQUAL(l.begin(), l.end());
265 }
266 
267 BOOST_AUTO_TEST_CASE_TEMPLATE(one_item_begin_is_not_end, Mdl, thread_types)
268 {
269  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
270 
271  container_t l;
272  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
273  l.push(val);
274  BOOST_CHECK(!l.empty());
275  BOOST_CHECK_NE(l.begin(), l.end());
276 }
277 
278 BOOST_AUTO_TEST_CASE_TEMPLATE(one_item_begin_is_first, Mdl, thread_types)
279 {
280  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
281 
282  container_t l;
283  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
284  l.push(val);
285  BOOST_CHECK_EQUAL(*l.begin(), val);
286 }
287 
288 BOOST_AUTO_TEST_CASE_TEMPLATE(one_item_next_is_end, Mdl, thread_types)
289 {
290  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
291 
292  container_t l;
293  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
294  l.push(val);
295  typename container_t::iterator iter=l.begin();
296  ++iter;
297  BOOST_CHECK_NE(iter, l.begin());
298  BOOST_CHECK_EQUAL(iter, l.end());
299 }
300 
301 BOOST_AUTO_TEST_CASE_TEMPLATE(erase_item_size_one, Mdl, thread_types)
302 {
303  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
304 
305  container_t l;
306  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
307  l.push(val);
308  l.erase(l.begin());
309  BOOST_CHECK(l.empty());
310  BOOST_CHECK_EQUAL(l.size(), 0U);
311 }
312 
313 BOOST_AUTO_TEST_CASE_TEMPLATE(erase_item_size_two, Mdl, thread_types)
314 {
315  typedef intrusive::stack<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
316 
317  container_t l;
318  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
319  l.push(val1);
320  l.erase(l.begin());
321  BOOST_CHECK(l.empty());
322  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
323  l.push(val2);
324  BOOST_CHECK(!l.empty());
325  BOOST_CHECK_EQUAL(l.size(), 1U);
326 }
327 
328 BOOST_AUTO_TEST_SUITE_END()
329 
330 BOOST_AUTO_TEST_SUITE(slist)
331 
332 BOOST_AUTO_TEST_CASE_TEMPLATE(default_ctor, Mdl, thread_types)
333 {
334  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
335 
336  container_t l;
337  BOOST_CHECK(l.empty());
338  BOOST_CHECK_EQUAL(l.size(), 0U);
339  BOOST_CHECK(l.penultimate_reachable_from_prefront());
340 }
341 
342 BOOST_AUTO_TEST_CASE_TEMPLATE(push_back_one_item, Mdl, thread_types)
343 {
344  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
345 
346  container_t l;
347  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
348  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 1);
349  l.push_back(val);
350  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
351  BOOST_CHECK(!l.empty());
352  BOOST_CHECK_EQUAL(l.size(), 1U);
353  BOOST_CHECK(l.penultimate_reachable_from_prefront());
354 }
355 
356 BOOST_AUTO_TEST_CASE_TEMPLATE(push_back_and_pop_front_one_item, Mdl, thread_types)
357 {
358  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
359 
360  container_t l;
361  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
362  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 1);
363  l.push_back(val);
364  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
365  BOOST_CHECK(!l.empty());
366  BOOST_CHECK_EQUAL(l.size(), 1U);
367  BOOST_CHECK(l.penultimate_reachable_from_prefront());
368  typename container_t::value_type ret(l.front());
369  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 3);
370  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 3);
371  BOOST_CHECK_EQUAL(val, ret);
372  BOOST_CHECK(!l.empty());
373  BOOST_CHECK_EQUAL(l.size(), 1U);
374  l.pop_front();
375  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
376  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
377  BOOST_CHECK(l.empty());
378  BOOST_CHECK_EQUAL(l.size(), 0U);
379  BOOST_CHECK(l.penultimate_reachable_from_prefront());
380 }
381 
382 BOOST_AUTO_TEST_CASE_TEMPLATE(push_back_two_items, Mdl, thread_types)
383 {
384  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
385 
386  container_t l;
387  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
388  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
389  l.push_back(val1);
390  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
391  BOOST_CHECK(!l.empty());
392  BOOST_CHECK_EQUAL(l.size(), 1U);
393  BOOST_CHECK(l.penultimate_reachable_from_prefront());
394  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
395  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
396  l.push_back(val2);
397  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
398  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
399  BOOST_CHECK(!l.empty());
400  BOOST_CHECK_EQUAL(l.size(), 2U);
401  BOOST_CHECK(l.penultimate_reachable_from_prefront());
402 }
403 
404 BOOST_AUTO_TEST_CASE_TEMPLATE(push_back_two_items_pop_one1, Mdl, thread_types)
405 {
406  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
407 
408  container_t l;
409  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
410  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
411  l.push_back(val1);
412  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
413  BOOST_CHECK(!l.empty());
414  BOOST_CHECK_EQUAL(l.size(), 1U);
415  typename container_t::value_type ret(l.front());
416  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 3);
417  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 3);
418  BOOST_CHECK_EQUAL(val1, ret);
419  BOOST_CHECK(!l.empty());
420  BOOST_CHECK_EQUAL(l.size(), 1U);
421  BOOST_CHECK(l.penultimate_reachable_from_prefront());
422  l.pop_front();
423  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
424  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
425  BOOST_CHECK(l.empty());
426  BOOST_CHECK_EQUAL(l.size(), 0U);
427  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
428  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
429  BOOST_CHECK(l.penultimate_reachable_from_prefront());
430  l.push_back(val2);
431  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
432  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
433  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
434  BOOST_CHECK(!l.empty());
435  BOOST_CHECK_EQUAL(l.size(), 1U);
436  BOOST_CHECK(l.penultimate_reachable_from_prefront());
437 }
438 
439 BOOST_AUTO_TEST_CASE_TEMPLATE(push_back_two_items_pop_one2, Mdl, thread_types)
440 {
441  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
442 
443  container_t l;
444  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
445  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
446  l.push_back(val1);
447  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
448  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
449  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
450  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
451  BOOST_CHECK(l.penultimate_reachable_from_prefront());
452  l.push_back(val2);
453  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
454  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
455  typename container_t::value_type ret(l.front());
456  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 3);
457  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 3);
458  BOOST_CHECK_EQUAL(val1, ret);
459  BOOST_CHECK(!l.empty());
460  BOOST_CHECK_EQUAL(l.size(), 2U);
461  BOOST_CHECK(l.penultimate_reachable_from_prefront());
462  l.pop_front();
463  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
464  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
465  BOOST_CHECK(!l.empty());
466  BOOST_CHECK_EQUAL(l.size(), 1U);
467  BOOST_CHECK(l.penultimate_reachable_from_prefront());
468 }
469 
470 BOOST_AUTO_TEST_CASE_TEMPLATE(push_back_two_items_pop_two, Mdl, thread_types)
471 {
472  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
473 
474  container_t l;
475  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
476  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
477  l.push_back(val1);
478  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
479  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
480  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
481  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
482  l.push_back(val2);
483  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
484  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
485  typename container_t::value_type ret1(l.front());
486  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 3);
487  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 3);
488  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
489  BOOST_CHECK_EQUAL(val1, ret1);
490  BOOST_CHECK(!l.empty());
491  BOOST_CHECK_EQUAL(l.size(), 2U);
492  l.pop_front();
493  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
494  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
495  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
496  BOOST_CHECK(!l.empty());
497  BOOST_CHECK_EQUAL(l.size(), 1U);
498  typename container_t::value_type ret2(l.front());
499  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
500  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 3);
501  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
502  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 3);
503  BOOST_CHECK_EQUAL(val2, ret2);
504  BOOST_CHECK(!l.empty());
505  BOOST_CHECK_EQUAL(l.size(), 1U);
506  l.pop_front();
507  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
508  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
509  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
510  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
511  BOOST_CHECK(l.empty());
512  BOOST_CHECK_EQUAL(l.size(), 0U);
513  BOOST_CHECK(l.penultimate_reachable_from_prefront());
514 }
515 
516 BOOST_AUTO_TEST_CASE_TEMPLATE(push_back_three_items_pop_three, Mdl, thread_types)
517 {
518  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
519 
520  container_t l;
521  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
522  l.push_back(val1);
523  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
524  l.push_back(val2);
525  typename container_t::value_type val3(new typename container_t::value_type::value_type(3));
526  l.push_back(val3);
527  BOOST_CHECK(l.penultimate_reachable_from_prefront());
528  typename container_t::value_type ret1(l.front());
529  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 3);
530  BOOST_CHECK_EQUAL(val1, ret1);
531  BOOST_CHECK(!l.empty());
532  BOOST_CHECK_EQUAL(l.size(), 3U);
533  l.pop_front();
534  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
535  BOOST_CHECK(!l.empty());
536  BOOST_CHECK_EQUAL(l.size(), 2U);
537  typename container_t::value_type ret2(l.front());
538  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 3);
539  BOOST_CHECK_EQUAL(val2, ret2);
540  BOOST_CHECK(!l.empty());
541  BOOST_CHECK_EQUAL(l.size(), 2U);
542  l.pop_front();
543  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
544  BOOST_CHECK(!l.empty());
545  BOOST_CHECK_EQUAL(l.size(), 1U);
546  typename container_t::value_type ret3(l.front());
547  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 3);
548  BOOST_CHECK_EQUAL(val3, ret3);
549  BOOST_CHECK(!l.empty());
550  BOOST_CHECK_EQUAL(l.size(), 1U);
551  l.pop_front();
552  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
553  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
554  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
555  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
556  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
557  BOOST_CHECK(l.empty());
558  BOOST_CHECK_EQUAL(l.size(), 0U);
559  BOOST_CHECK(l.penultimate_reachable_from_prefront());
560 }
561 
562 BOOST_AUTO_TEST_CASE_TEMPLATE(push_front_one_item, Mdl, thread_types)
563 {
564  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
565 
566  container_t l;
567  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
568  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 1);
569  l.push_front(val);
570  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
571  BOOST_CHECK(!l.empty());
572  BOOST_CHECK_EQUAL(l.size(), 1U);
573  BOOST_CHECK(l.penultimate_reachable_from_prefront());
574 }
575 
576 BOOST_AUTO_TEST_CASE_TEMPLATE(push_and_pop_front_one_item, Mdl, thread_types)
577 {
578  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
579 
580  container_t l;
581  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
582  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 1);
583  l.push_front(val);
584  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
585  typename container_t::value_type ret(l.front());
586  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 3);
587  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 3);
588  BOOST_CHECK_EQUAL(val, ret);
589  BOOST_CHECK(!l.empty());
590  BOOST_CHECK_EQUAL(l.size(), 1U);
591  l.pop_front();
592  BOOST_CHECK_EQUAL(val.get().get()->sp_count(), 2);
593  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
594  BOOST_CHECK(l.empty());
595  BOOST_CHECK_EQUAL(l.size(), 0U);
596  BOOST_CHECK(l.penultimate_reachable_from_prefront());
597 }
598 
599 BOOST_AUTO_TEST_CASE_TEMPLATE(push_front_two_items, Mdl, thread_types)
600 {
601  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
602 
603  container_t l;
604  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
605  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
606  l.push_front(val1);
607  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
608  BOOST_CHECK(!l.empty());
609  BOOST_CHECK_EQUAL(l.size(), 1U);
610  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
611  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
612  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
613  l.push_front(val2);
614  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
615  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
616  BOOST_CHECK(!l.empty());
617  BOOST_CHECK_EQUAL(l.size(), 2U);
618  BOOST_CHECK(l.penultimate_reachable_from_prefront());
619 }
620 
621 BOOST_AUTO_TEST_CASE_TEMPLATE(push_front_and_back_one_item, Mdl, thread_types)
622 {
623  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
624 
625  container_t l;
626  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
627  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
628  l.push_front(val1);
629  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
630  BOOST_CHECK(!l.empty());
631  BOOST_CHECK_EQUAL(l.size(), 1U);
632  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
633  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
634  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
635  l.push_back(val2);
636  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
637  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
638  BOOST_CHECK(!l.empty());
639  BOOST_CHECK_EQUAL(l.size(), 2U);
640  BOOST_CHECK(l.penultimate_reachable_from_prefront());
641 }
642 
643 BOOST_AUTO_TEST_CASE_TEMPLATE(push_front_two_items_pop_one1, Mdl, thread_types)
644 {
645  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
646 
647  container_t l;
648  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
649  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 1);
650  l.push_front(val1);
651  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
652  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
653  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 1);
654  l.push_front(val2);
655  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
656  typename container_t::value_type ret(l.front());
657  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
658  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 3);
659  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 3);
660  BOOST_CHECK_EQUAL(val2, ret);
661  BOOST_CHECK(!l.empty());
662  BOOST_CHECK_EQUAL(l.size(), 2U);
663  l.pop_front();
664  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
665  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
666  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
667  BOOST_CHECK(!l.empty());
668  BOOST_CHECK_EQUAL(l.size(), 1U);
669  BOOST_CHECK(l.penultimate_reachable_from_prefront());
670 }
671 
672 BOOST_AUTO_TEST_CASE_TEMPLATE(push_front_two_items_pop_one2, Mdl, thread_types)
673 {
674  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
675 
676  container_t l;
677  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
678  l.push_front(val1);
679  typename container_t::value_type ret(l.front());
680  BOOST_CHECK_EQUAL(val1, ret);
681  BOOST_CHECK(!l.empty());
682  BOOST_CHECK_EQUAL(l.size(), 1U);
683  l.pop_front();
684  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
685  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
686  BOOST_CHECK(l.empty());
687  BOOST_CHECK_EQUAL(l.size(), 0U);
688  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
689  l.push_front(val2);
690  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
691  BOOST_CHECK_EQUAL(ret.get().get()->sp_count(), 2);
692  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
693  BOOST_CHECK(!l.empty());
694  BOOST_CHECK_EQUAL(l.size(), 1U);
695  BOOST_CHECK(l.penultimate_reachable_from_prefront());
696 }
697 
698 BOOST_AUTO_TEST_CASE_TEMPLATE(push_front_two_items_pop_two, Mdl, thread_types)
699 {
700  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
701 
702  container_t l;
703  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
704  l.push_front(val1);
705  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
706  l.push_front(val2);
707  typename container_t::value_type ret2(l.front());
708  BOOST_CHECK_EQUAL(val2, ret2);
709  BOOST_CHECK(!l.empty());
710  BOOST_CHECK_EQUAL(l.size(), 2U);
711  l.pop_front();
712  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
713  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
714  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
715  BOOST_CHECK(!l.empty());
716  BOOST_CHECK_EQUAL(l.size(), 1U);
717  typename container_t::value_type ret1(l.front());
718  BOOST_CHECK_EQUAL(val1, ret1);
719  BOOST_CHECK(!l.empty());
720  BOOST_CHECK_EQUAL(l.size(), 1U);
721  l.pop_front();
722  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
723  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
724  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
725  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
726  BOOST_CHECK(l.empty());
727  BOOST_CHECK_EQUAL(l.size(), 0U);
728  BOOST_CHECK(l.penultimate_reachable_from_prefront());
729 }
730 
731 BOOST_AUTO_TEST_CASE_TEMPLATE(push_front_three_items_pop_three, Mdl, thread_types)
732 {
733  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
734 
735  container_t l;
736  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
737  l.push_front(val1);
738  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
739  l.push_front(val2);
740  typename container_t::value_type val3(new typename container_t::value_type::value_type(3));
741  l.push_front(val3);
742  typename container_t::value_type ret3(l.front());
743  BOOST_CHECK_EQUAL(val3, ret3);
744  BOOST_CHECK(!l.empty());
745  BOOST_CHECK_EQUAL(l.size(), 3U);
746  l.pop_front();
747  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
748  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
749  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
750  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
751  BOOST_CHECK(!l.empty());
752  BOOST_CHECK_EQUAL(l.size(), 2U);
753  typename container_t::value_type ret2(l.front());
754  BOOST_CHECK_EQUAL(val2, ret2);
755  BOOST_CHECK(!l.empty());
756  BOOST_CHECK_EQUAL(l.size(), 2U);
757  l.pop_front();
758  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
759  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
760  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
761  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
762  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
763  BOOST_CHECK(!l.empty());
764  BOOST_CHECK_EQUAL(l.size(), 1U);
765  typename container_t::value_type ret1(l.front());
766  BOOST_CHECK_EQUAL(val1, ret1);
767  BOOST_CHECK(!l.empty());
768  BOOST_CHECK_EQUAL(l.size(), 1U);
769  l.pop_front();
770  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
771  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
772  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
773  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
774  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
775  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
776  BOOST_CHECK(l.empty());
777  BOOST_CHECK_EQUAL(l.size(), 0U);
778  BOOST_CHECK(l.penultimate_reachable_from_prefront());
779 }
780 
781 BOOST_AUTO_TEST_CASE_TEMPLATE(mixed_push_pop_three_items1, Mdl, thread_types)
782 {
783  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
784 
785  container_t l;
786  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
787  l.push_front(val1);
788  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
789  l.push_back(val2);
790  typename container_t::value_type val3(new typename container_t::value_type::value_type(3));
791  l.push_front(val3);
792  typename container_t::value_type ret3(l.front());
793  BOOST_CHECK_EQUAL(val3, ret3);
794  BOOST_CHECK(!l.empty());
795  BOOST_CHECK_EQUAL(l.size(), 3U);
796  BOOST_CHECK(l.penultimate_reachable_from_prefront());
797  l.pop_front();
798  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
799  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
800  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
801  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
802  BOOST_CHECK(!l.empty());
803  BOOST_CHECK_EQUAL(l.size(), 2U);
804  typename container_t::value_type ret1(l.front());
805  BOOST_CHECK_EQUAL(val1, ret1);
806  BOOST_CHECK(!l.empty());
807  BOOST_CHECK_EQUAL(l.size(), 2U);
808  l.pop_front();
809  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
810  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
811  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
812  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
813  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
814  BOOST_CHECK(!l.empty());
815  BOOST_CHECK_EQUAL(l.size(), 1U);
816  typename container_t::value_type ret2(l.front());
817  BOOST_CHECK_EQUAL(val2, ret2);
818  BOOST_CHECK(!l.empty());
819  BOOST_CHECK_EQUAL(l.size(), 1U);
820  l.pop_front();
821  BOOST_CHECK_EQUAL(val1.get().get()->sp_count(), 2);
822  BOOST_CHECK_EQUAL(ret1.get().get()->sp_count(), 2);
823  BOOST_CHECK_EQUAL(val2.get().get()->sp_count(), 2);
824  BOOST_CHECK_EQUAL(ret2.get().get()->sp_count(), 2);
825  BOOST_CHECK_EQUAL(val3.get().get()->sp_count(), 2);
826  BOOST_CHECK_EQUAL(ret3.get().get()->sp_count(), 2);
827  BOOST_CHECK(l.empty());
828  BOOST_CHECK_EQUAL(l.size(), 0U);
829  BOOST_CHECK(l.penultimate_reachable_from_prefront());
830 }
831 
832 BOOST_AUTO_TEST_CASE_TEMPLATE(find_item_size_one, Mdl, thread_types)
833 {
834  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
835 
836  container_t l;
837  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
838  l.push_front(val);
839  typename container_t::iterator i(l.find(val));
840  BOOST_CHECK_NE(i, l.end());
841  BOOST_CHECK_EQUAL(*i, val);
842  BOOST_CHECK_EQUAL(i->i, val->i);
843 }
844 
845 BOOST_AUTO_TEST_CASE_TEMPLATE(not_find_wrong_item_size_one, Mdl, thread_types)
846 {
847  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
848 
849  container_t l;
850  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
851  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
852  l.push_front(val1);
853  typename container_t::iterator i(l.find(val2));
854  BOOST_CHECK_EQUAL(i, l.end());
855 }
856 
857 BOOST_AUTO_TEST_CASE_TEMPLATE(not_find_item_popped_size_one, Mdl, thread_types)
858 {
859  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
860 
861  container_t l;
862  typename container_t::value_type val(new typename container_t::value_type::value_type(1));
863  l.push_front(val);
864  typename container_t::iterator i(l.find(val));
865  BOOST_CHECK_NE(i, l.end());
866  BOOST_CHECK_EQUAL(*i, val);
867  BOOST_CHECK_EQUAL(i->i, val->i);
868  l.pop_front();
869  typename container_t::iterator i1(l.find(val));
870  BOOST_CHECK_EQUAL(i1, l.end());
871  BOOST_CHECK(l.penultimate_reachable_from_prefront());
872 }
873 
874 BOOST_AUTO_TEST_CASE_TEMPLATE(not_find_item_popped_size_two, Mdl, thread_types)
875 {
876  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
877 
878  container_t l;
879  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
880  l.push_front(val1);
881  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
882  l.push_front(val2);
883  typename container_t::iterator i2_1(l.find(val2));
884  BOOST_CHECK_NE(i2_1, l.end());
885  BOOST_CHECK_EQUAL(*i2_1, val2);
886  BOOST_CHECK_EQUAL(i2_1->i, val2->i);
887  l.pop_front();
888  typename container_t::iterator i2_2(l.find(val2));
889  BOOST_CHECK_EQUAL(i2_2, l.end());
890  typename container_t::iterator i1(l.find(val1));
891  BOOST_CHECK_NE(i1, l.end());
892  BOOST_CHECK_EQUAL(*i1, val1);
893  BOOST_CHECK_EQUAL(i1->i, val1->i);
894  BOOST_CHECK(l.penultimate_reachable_from_prefront());
895 }
896 
897 BOOST_AUTO_TEST_CASE_TEMPLATE(find_item_size_two, Mdl, thread_types)
898 {
899  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
900 
901  container_t l;
902  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
903  l.push_front(val1);
904  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
905  l.push_back(val2);
906  typename container_t::iterator i1(l.find(val1));
907  BOOST_CHECK_NE(i1, l.end());
908  BOOST_CHECK_EQUAL(*i1, val1);
909  BOOST_CHECK_EQUAL(i1->i, val1->i);
910  typename container_t::iterator i2(l.find(val2));
911  BOOST_CHECK_NE(i2, l.end());
912  BOOST_CHECK_EQUAL(*i2, val2);
913  BOOST_CHECK_EQUAL(i2->i, val2->i);
914  BOOST_CHECK(l.penultimate_reachable_from_prefront());
915 }
916 
917 BOOST_AUTO_TEST_CASE_TEMPLATE(erase_item_size_one, Mdl, thread_types)
918 {
919  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
920 
921  container_t l;
922  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
923  l.push_front(val1);
924  BOOST_CHECK(l.penultimate_reachable_from_prefront());
925  l.erase(l.begin());
926  BOOST_CHECK(l.empty());
927  BOOST_CHECK(l.penultimate_reachable_from_prefront());
928  typename container_t::iterator i1(l.find(val1));
929  BOOST_CHECK_EQUAL(i1, l.end());
930  BOOST_CHECK(l.penultimate_reachable_from_prefront());
931 }
932 
933 BOOST_AUTO_TEST_CASE_TEMPLATE(erase_item_size_two1, Mdl, thread_types)
934 {
935  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
936 
937  container_t l;
938  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
939  l.push_front(val1);
940  BOOST_CHECK(l.penultimate_reachable_from_prefront());
941  l.erase(l.begin());
942  BOOST_CHECK(l.empty());
943  BOOST_CHECK(l.penultimate_reachable_from_prefront());
944  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
945  l.push_front(val2);
946  BOOST_CHECK(!l.empty());
947  BOOST_CHECK_EQUAL(l.size(), 1U);
948  BOOST_CHECK(l.penultimate_reachable_from_prefront());
949  BOOST_CHECK(l.penultimate_reachable_from_prefront());
950 }
951 
952 BOOST_AUTO_TEST_CASE_TEMPLATE(erase_item_size_two2, Mdl, thread_types)
953 {
954  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
955 
956  container_t l;
957  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
958  l.push_front(val1);
959  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
960  l.push_front(val2);
961  BOOST_CHECK(l.penultimate_reachable_from_prefront());
962  l.erase(l.begin());
963  BOOST_CHECK(!l.empty());
964  BOOST_CHECK_EQUAL(l.size(), 1U);
965  BOOST_CHECK(l.penultimate_reachable_from_prefront());
966  typename container_t::iterator i2(l.find(val2));
967  BOOST_CHECK_EQUAL(i2, l.end());
968  typename container_t::iterator i1(l.find(val1));
969  BOOST_CHECK_NE(i1, l.end());
970  BOOST_CHECK_EQUAL(*i1, val1);
971  BOOST_CHECK_EQUAL(i1->i, val1->i);
972  BOOST_CHECK(l.penultimate_reachable_from_prefront());
973 }
974 
975 BOOST_AUTO_TEST_CASE_TEMPLATE(find_erase_middle_three_items, Mdl, thread_types)
976 {
977  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
978 
979  container_t l;
980  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
981  l.push_front(val1);
982  BOOST_CHECK_EQUAL(l.size(), 1U);
983  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
984  l.push_back(val2);
985  BOOST_CHECK_EQUAL(l.size(), 2U);
986  typename container_t::value_type val3(new typename container_t::value_type::value_type(3));
987  l.push_front(val3);
988  BOOST_CHECK_EQUAL(l.size(), 3U);
989  BOOST_CHECK(l.penultimate_reachable_from_prefront());
990  typename container_t::iterator chk(l.begin());
991  BOOST_CHECK_EQUAL(chk->i, val3->i);
992  BOOST_CHECK_EQUAL((++chk)->i, val1->i);
993  BOOST_CHECK_EQUAL((++chk)->i, val2->i);
994  typename container_t::iterator i1_1(l.find(val1));
995  BOOST_CHECK_NE(i1_1, l.end());
996  BOOST_CHECK_EQUAL(i1_1->i, val1->i);
997  l.erase(i1_1);
998  BOOST_CHECK_EQUAL(l.size(), 2U);
999  BOOST_CHECK(l.penultimate_reachable_from_prefront());
1000  chk=l.begin();
1001  BOOST_CHECK_EQUAL(chk->i, val3->i);
1002  BOOST_CHECK_EQUAL((++chk)->i, val2->i);
1003  typename container_t::iterator i1_2(l.find(val1));
1004  BOOST_CHECK_EQUAL(i1_2, l.end());
1005  typename container_t::iterator i2(l.find(val2));
1006  BOOST_CHECK_NE(i2, l.end());
1007  BOOST_CHECK_EQUAL(*i2, val2);
1008  BOOST_CHECK_EQUAL(i2->i, val2->i);
1009  typename container_t::iterator i3(l.find(val3));
1010  BOOST_CHECK_NE(i3, l.end());
1011  BOOST_CHECK_EQUAL(*i3, val3);
1012  BOOST_CHECK_EQUAL(i3->i, val3->i);
1013  BOOST_CHECK(l.penultimate_reachable_from_prefront());
1014 }
1015 
1016 BOOST_AUTO_TEST_CASE_TEMPLATE(check_iterator_walks_through_list, Mdl, thread_types)
1017 {
1018  typedef intrusive::slist<data<api_lock_traits<platform_api, Mdl> >, api_lock_traits<platform_api, Mdl>> container_t;
1019 
1020  container_t l;
1021  typename container_t::value_type val1(new typename container_t::value_type::value_type(1));
1022  typename container_t::value_type val2(new typename container_t::value_type::value_type(2));
1023  typename container_t::value_type val3(new typename container_t::value_type::value_type(3));
1024  l.push_back(val2);
1025  l.push_front(val1);
1026  l.push_back(val3);
1027  typename container_t::iterator i(l.begin());
1028  BOOST_CHECK_EQUAL(*i, val1);
1029  BOOST_CHECK_EQUAL(i->i, val1->i);
1030  ++i;
1031  BOOST_CHECK_NE(i, l.end());
1032  BOOST_CHECK_EQUAL(*i, val2);
1033  BOOST_CHECK_EQUAL(i->i, val2->i);
1034  ++i;
1035  BOOST_CHECK_NE(i, l.end());
1036  BOOST_CHECK_EQUAL(*i, val3);
1037  BOOST_CHECK_EQUAL(i->i, val3->i);
1038  ++i;
1039  BOOST_CHECK_EQUAL(i, l.end());
1040  ++i;
1041  BOOST_CHECK_EQUAL(i, l.end());
1042  ++i;
1043  BOOST_CHECK_EQUAL(i, l.end());
1044  BOOST_CHECK(l.penultimate_reachable_from_prefront());
1045 }
1046 
1047 BOOST_AUTO_TEST_SUITE_END()
1048 
1049 BOOST_AUTO_TEST_SUITE_END()