1 : // $Id: IteratorTest.cc 113 2008-09-07 15:25:51Z tb $
2 :
3 : /*
4 : * STX B+ Tree Template Classes v0.8.3
5 : * Copyright (C) 2008 Timo Bingmann
6 : *
7 : * This library is free software; you can redistribute it and/or modify it
8 : * under the terms of the GNU Lesser General Public License as published by the
9 : * Free Software Foundation; either version 2.1 of the License, or (at your
10 : * option) any later version.
11 : *
12 : * This library is distributed in the hope that it will be useful, but WITHOUT
13 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
15 : * for more details.
16 : *
17 : * You should have received a copy of the GNU Lesser General Public License
18 : * along with this library; if not, write to the Free Software Foundation,
19 : * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 : */
21 :
22 : #include <cppunit/extensions/HelperMacros.h>
23 :
24 : #include <stdlib.h>
25 :
26 : #include <vector>
27 :
28 : #include <stx/btree_multiset.h>
29 : #include <stx/btree_multimap.h>
30 : #include <stx/btree_map.h>
31 : #include <stx/btree_set.h>
32 :
33 : class IteratorTest : public CPPUNIT_NS::TestFixture
34 10 : {
35 3 : CPPUNIT_TEST_SUITE( IteratorTest );
36 1 : CPPUNIT_TEST(test_iterator1);
37 2 : CPPUNIT_TEST(test_iterator2);
38 2 : CPPUNIT_TEST(test_iterator3);
39 2 : CPPUNIT_TEST(test_iterator4);
40 2 : CPPUNIT_TEST(test_iterator5);
41 2 : CPPUNIT_TEST_SUITE_END();
42 :
43 : protected:
44 :
45 : struct traits_nodebug
46 : {
47 : static const bool selfverify = true;
48 : static const bool debug = false;
49 :
50 : static const int leafslots = 8;
51 : static const int innerslots = 8;
52 : };
53 :
54 1 : void test_iterator1()
55 : {
56 : typedef stx::btree_multiset<unsigned int,
57 : std::less<unsigned int>, struct traits_nodebug> btree_type;
58 :
59 1 : std::vector<unsigned int> vector;
60 :
61 1 : srand(34234235);
62 3201 : for(unsigned int i = 0; i < 3200; i++)
63 : {
64 3200 : vector.push_back( rand() % 1000 );
65 : }
66 :
67 1 : CPPUNIT_ASSERT( vector.size() == 3200 );
68 :
69 : // test construction and insert(iter, iter) function
70 2 : btree_type bt(vector.begin(), vector.end());
71 :
72 1 : CPPUNIT_ASSERT( bt.size() == 3200 );
73 :
74 : // copy for later use
75 1 : btree_type bt2 = bt;
76 :
77 : // empty out the first bt
78 1 : srand(34234235);
79 6402 : for(unsigned int i = 0; i < 3200; i++)
80 : {
81 3200 : CPPUNIT_ASSERT(bt.size() == 3200 - i);
82 6400 : CPPUNIT_ASSERT( bt.erase_one(rand() % 1000) );
83 6400 : CPPUNIT_ASSERT(bt.size() == 3200 - i - 1);
84 : }
85 :
86 1 : CPPUNIT_ASSERT( bt.empty() );
87 :
88 : // copy btree values back to a vector
89 :
90 2 : std::vector<unsigned int> vector2;
91 2 : vector2.assign( bt2.begin(), bt2.end() );
92 :
93 : // afer sorting the vector, the two must be the same
94 1 : std::sort(vector.begin(), vector.end());
95 :
96 1 : CPPUNIT_ASSERT( vector == vector2 );
97 :
98 : // test reverse iterator
99 1 : vector2.clear();
100 1 : vector2.assign( bt2.rbegin(), bt2.rend() );
101 :
102 1 : std::reverse(vector.begin(), vector.end());
103 :
104 1 : btree_type::reverse_iterator ri = bt2.rbegin();
105 6402 : for(unsigned int i = 0; i < vector2.size(); ++i)
106 : {
107 3200 : CPPUNIT_ASSERT( vector[i] == vector2[i] );
108 6400 : CPPUNIT_ASSERT( vector[i] == *ri );
109 :
110 3200 : ri++;
111 : }
112 :
113 1 : CPPUNIT_ASSERT( ri == bt2.rend() );
114 1 : }
115 :
116 1 : void test_iterator2()
117 : {
118 : typedef stx::btree_multimap<unsigned int, unsigned int,
119 : std::less<unsigned int>, struct traits_nodebug> btree_type;
120 :
121 1 : std::vector< btree_type::value_type > vector;
122 :
123 1 : srand(34234235);
124 3201 : for(unsigned int i = 0; i < 3200; i++)
125 : {
126 3200 : vector.push_back( btree_type::value_type(rand() % 1000, 0) );
127 : }
128 :
129 1 : CPPUNIT_ASSERT( vector.size() == 3200 );
130 :
131 : // test construction and insert(iter, iter) function
132 2 : btree_type bt(vector.begin(), vector.end());
133 :
134 1 : CPPUNIT_ASSERT( bt.size() == 3200 );
135 :
136 : // copy for later use
137 1 : btree_type bt2 = bt;
138 :
139 : // empty out the first bt
140 1 : srand(34234235);
141 6402 : for(unsigned int i = 0; i < 3200; i++)
142 : {
143 3200 : CPPUNIT_ASSERT(bt.size() == 3200 - i);
144 6400 : CPPUNIT_ASSERT( bt.erase_one(rand() % 1000) );
145 6400 : CPPUNIT_ASSERT(bt.size() == 3200 - i - 1);
146 : }
147 :
148 1 : CPPUNIT_ASSERT( bt.empty() );
149 :
150 : // copy btree values back to a vector
151 :
152 2 : std::vector< btree_type::value_type > vector2;
153 2 : vector2.assign( bt2.begin(), bt2.end() );
154 :
155 : // afer sorting the vector, the two must be the same
156 1 : std::sort(vector.begin(), vector.end());
157 :
158 1 : CPPUNIT_ASSERT( vector == vector2 );
159 :
160 : // test reverse iterator
161 1 : vector2.clear();
162 1 : vector2.assign( bt2.rbegin(), bt2.rend() );
163 :
164 1 : std::reverse(vector.begin(), vector.end());
165 :
166 1 : btree_type::reverse_iterator ri = bt2.rbegin();
167 6402 : for(unsigned int i = 0; i < vector2.size(); ++i, ++ri)
168 : {
169 3200 : CPPUNIT_ASSERT( vector[i].first == vector2[i].first );
170 6400 : CPPUNIT_ASSERT( vector[i].first == ri->first );
171 6400 : CPPUNIT_ASSERT( vector[i].second == ri->second );
172 : }
173 :
174 1 : CPPUNIT_ASSERT( ri == bt2.rend() );
175 1 : }
176 :
177 1 : void test_iterator3()
178 : {
179 : typedef stx::btree_map<unsigned int, unsigned int,
180 : std::less<unsigned int>, struct traits_nodebug> btree_type;
181 :
182 1 : btree_type map;
183 :
184 1 : unsigned int maxnum = 1000;
185 :
186 1001 : for(unsigned int i = 0; i < maxnum; ++i)
187 : {
188 1000 : map.insert( std::make_pair(i, i*3) );
189 : }
190 :
191 : { // test iterator prefix++
192 1 : unsigned int nownum = 0;
193 :
194 2002 : for(btree_type::iterator i = map.begin();
195 : i != map.end(); ++i)
196 : {
197 1000 : CPPUNIT_ASSERT( nownum == i->first );
198 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
199 :
200 1000 : nownum++;
201 : }
202 :
203 1 : CPPUNIT_ASSERT(nownum == maxnum);
204 : }
205 :
206 : { // test iterator prefix--
207 1 : unsigned int nownum = maxnum;
208 :
209 1 : btree_type::iterator i;
210 2000 : for(i = --map.end(); i != map.begin(); --i)
211 : {
212 999 : nownum--;
213 :
214 999 : CPPUNIT_ASSERT( nownum == i->first );
215 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
216 : }
217 :
218 1 : nownum--;
219 :
220 1 : CPPUNIT_ASSERT( nownum == i->first );
221 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
222 :
223 2 : CPPUNIT_ASSERT(nownum == 0);
224 : }
225 :
226 : { // test const_iterator prefix++
227 1 : unsigned int nownum = 0;
228 :
229 2003 : for(btree_type::const_iterator i = map.begin();
230 : i != map.end(); ++i)
231 : {
232 1000 : CPPUNIT_ASSERT( nownum == i->first );
233 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
234 :
235 1000 : nownum++;
236 : }
237 :
238 1 : CPPUNIT_ASSERT(nownum == maxnum);
239 : }
240 :
241 : { // test const_iterator prefix--
242 1 : unsigned int nownum = maxnum;
243 :
244 1 : btree_type::const_iterator i;
245 2000 : for(i = --map.end(); i != map.begin(); --i)
246 : {
247 999 : nownum--;
248 :
249 999 : CPPUNIT_ASSERT( nownum == i->first );
250 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
251 : }
252 :
253 1 : nownum--;
254 :
255 1 : CPPUNIT_ASSERT( nownum == i->first );
256 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
257 :
258 2 : CPPUNIT_ASSERT(nownum == 0);
259 : }
260 :
261 : { // test reverse_iterator prefix++
262 1 : unsigned int nownum = maxnum;
263 :
264 2003 : for(btree_type::reverse_iterator i = map.rbegin();
265 : i != map.rend(); ++i)
266 : {
267 1000 : nownum--;
268 :
269 1000 : CPPUNIT_ASSERT( nownum == i->first );
270 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
271 : }
272 :
273 1 : CPPUNIT_ASSERT(nownum == 0);
274 : }
275 :
276 : { // test reverse_iterator prefix--
277 1 : unsigned int nownum = 0;
278 :
279 1 : btree_type::reverse_iterator i;
280 2000 : for(i = --map.rend(); i != map.rbegin(); --i)
281 : {
282 999 : CPPUNIT_ASSERT( nownum == i->first );
283 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
284 :
285 999 : nownum++;
286 : }
287 :
288 1 : CPPUNIT_ASSERT( nownum == i->first );
289 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
290 :
291 1 : nownum++;
292 :
293 2 : CPPUNIT_ASSERT(nownum == maxnum);
294 : }
295 :
296 : { // test const_reverse_iterator prefix++
297 1 : unsigned int nownum = maxnum;
298 :
299 2003 : for(btree_type::const_reverse_iterator i = map.rbegin();
300 : i != map.rend(); ++i)
301 : {
302 1000 : nownum--;
303 :
304 1000 : CPPUNIT_ASSERT( nownum == i->first );
305 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
306 : }
307 :
308 1 : CPPUNIT_ASSERT(nownum == 0);
309 : }
310 :
311 : { // test const_reverse_iterator prefix--
312 1 : unsigned int nownum = 0;
313 :
314 1 : btree_type::const_reverse_iterator i;
315 2000 : for(i = --map.rend(); i != map.rbegin(); --i)
316 : {
317 999 : CPPUNIT_ASSERT( nownum == i->first );
318 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
319 :
320 999 : nownum++;
321 : }
322 :
323 1 : CPPUNIT_ASSERT( nownum == i->first );
324 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
325 :
326 1 : nownum++;
327 :
328 2 : CPPUNIT_ASSERT(nownum == maxnum);
329 : }
330 :
331 : // postfix
332 :
333 : { // test iterator postfix++
334 1 : unsigned int nownum = 0;
335 :
336 2003 : for(btree_type::iterator i = map.begin();
337 : i != map.end(); i++)
338 : {
339 1000 : CPPUNIT_ASSERT( nownum == i->first );
340 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
341 :
342 1000 : nownum++;
343 : }
344 :
345 1 : CPPUNIT_ASSERT(nownum == maxnum);
346 : }
347 :
348 : { // test iterator postfix--
349 1 : unsigned int nownum = maxnum;
350 :
351 1 : btree_type::iterator i;
352 2000 : for(i = --map.end(); i != map.begin(); i--)
353 : {
354 999 : nownum--;
355 :
356 999 : CPPUNIT_ASSERT( nownum == i->first );
357 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
358 : }
359 :
360 1 : nownum--;
361 :
362 1 : CPPUNIT_ASSERT( nownum == i->first );
363 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
364 :
365 2 : CPPUNIT_ASSERT(nownum == 0);
366 : }
367 :
368 : { // test const_iterator postfix++
369 1 : unsigned int nownum = 0;
370 :
371 2003 : for(btree_type::const_iterator i = map.begin();
372 : i != map.end(); i++)
373 : {
374 1000 : CPPUNIT_ASSERT( nownum == i->first );
375 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
376 :
377 1000 : nownum++;
378 : }
379 :
380 1 : CPPUNIT_ASSERT(nownum == maxnum);
381 : }
382 :
383 : { // test const_iterator postfix--
384 1 : unsigned int nownum = maxnum;
385 :
386 1 : btree_type::const_iterator i;
387 2000 : for(i = --map.end(); i != map.begin(); i--)
388 : {
389 999 : nownum--;
390 :
391 999 : CPPUNIT_ASSERT( nownum == i->first );
392 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
393 : }
394 :
395 1 : nownum--;
396 :
397 1 : CPPUNIT_ASSERT( nownum == i->first );
398 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
399 :
400 2 : CPPUNIT_ASSERT(nownum == 0);
401 : }
402 :
403 : { // test reverse_iterator postfix++
404 1 : unsigned int nownum = maxnum;
405 :
406 2003 : for(btree_type::reverse_iterator i = map.rbegin();
407 : i != map.rend(); i++)
408 : {
409 1000 : nownum--;
410 :
411 1000 : CPPUNIT_ASSERT( nownum == i->first );
412 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
413 : }
414 :
415 1 : CPPUNIT_ASSERT(nownum == 0);
416 : }
417 :
418 : { // test reverse_iterator postfix--
419 1 : unsigned int nownum = 0;
420 :
421 1 : btree_type::reverse_iterator i;
422 2000 : for(i = --map.rend(); i != map.rbegin(); i--)
423 : {
424 999 : CPPUNIT_ASSERT( nownum == i->first );
425 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
426 :
427 999 : nownum++;
428 : }
429 :
430 1 : CPPUNIT_ASSERT( nownum == i->first );
431 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
432 :
433 1 : nownum++;
434 :
435 2 : CPPUNIT_ASSERT(nownum == maxnum);
436 : }
437 :
438 : { // test const_reverse_iterator postfix++
439 1 : unsigned int nownum = maxnum;
440 :
441 2003 : for(btree_type::const_reverse_iterator i = map.rbegin();
442 : i != map.rend(); i++)
443 : {
444 1000 : nownum--;
445 :
446 1000 : CPPUNIT_ASSERT( nownum == i->first );
447 2000 : CPPUNIT_ASSERT( nownum * 3 == i->second );
448 : }
449 :
450 1 : CPPUNIT_ASSERT(nownum == 0);
451 : }
452 :
453 : { // test const_reverse_iterator postfix--
454 1 : unsigned int nownum = 0;
455 :
456 1 : btree_type::const_reverse_iterator i;
457 2000 : for(i = --map.rend(); i != map.rbegin(); i--)
458 : {
459 999 : CPPUNIT_ASSERT( nownum == i->first );
460 1998 : CPPUNIT_ASSERT( nownum * 3 == i->second );
461 :
462 999 : nownum++;
463 : }
464 :
465 1 : CPPUNIT_ASSERT( nownum == i->first );
466 2 : CPPUNIT_ASSERT( nownum * 3 == i->second );
467 :
468 1 : nownum++;
469 :
470 2 : CPPUNIT_ASSERT(nownum == maxnum);
471 1 : }
472 1 : }
473 :
474 1 : void test_iterator4()
475 : {
476 : typedef stx::btree_set<unsigned int,
477 : std::less<unsigned int>, struct traits_nodebug> btree_type;
478 :
479 1 : btree_type set;
480 :
481 1 : unsigned int maxnum = 1000;
482 :
483 1001 : for(unsigned int i = 0; i < maxnum; ++i)
484 : {
485 1000 : set.insert(i);
486 : }
487 :
488 : { // test iterator prefix++
489 1 : unsigned int nownum = 0;
490 :
491 2002 : for(btree_type::iterator i = set.begin();
492 : i != set.end(); ++i)
493 : {
494 1000 : CPPUNIT_ASSERT( nownum == *i );
495 1000 : nownum++;
496 : }
497 :
498 1 : CPPUNIT_ASSERT(nownum == maxnum);
499 : }
500 :
501 : { // test iterator prefix--
502 1 : unsigned int nownum = maxnum;
503 :
504 1 : btree_type::iterator i;
505 2001 : for(i = --set.end(); i != set.begin(); --i)
506 : {
507 999 : CPPUNIT_ASSERT( --nownum == *i );
508 : }
509 :
510 1 : CPPUNIT_ASSERT( --nownum == *i );
511 :
512 2 : CPPUNIT_ASSERT(nownum == 0);
513 : }
514 :
515 : { // test const_iterator prefix++
516 1 : unsigned int nownum = 0;
517 :
518 2003 : for(btree_type::const_iterator i = set.begin();
519 : i != set.end(); ++i)
520 : {
521 1000 : CPPUNIT_ASSERT( nownum++ == *i );
522 : }
523 :
524 1 : CPPUNIT_ASSERT(nownum == maxnum);
525 : }
526 :
527 : { // test const_iterator prefix--
528 1 : unsigned int nownum = maxnum;
529 :
530 1 : btree_type::const_iterator i;
531 2001 : for(i = --set.end(); i != set.begin(); --i)
532 : {
533 999 : CPPUNIT_ASSERT( --nownum == *i );
534 : }
535 :
536 1 : CPPUNIT_ASSERT( --nownum == *i );
537 :
538 2 : CPPUNIT_ASSERT(nownum == 0);
539 : }
540 :
541 : { // test reverse_iterator prefix++
542 1 : unsigned int nownum = maxnum;
543 :
544 2003 : for(btree_type::reverse_iterator i = set.rbegin();
545 : i != set.rend(); ++i)
546 : {
547 1000 : CPPUNIT_ASSERT( --nownum == *i );
548 : }
549 :
550 1 : CPPUNIT_ASSERT(nownum == 0);
551 : }
552 :
553 : { // test reverse_iterator prefix--
554 1 : unsigned int nownum = 0;
555 :
556 1 : btree_type::reverse_iterator i;
557 2001 : for(i = --set.rend(); i != set.rbegin(); --i)
558 : {
559 999 : CPPUNIT_ASSERT( nownum++ == *i );
560 : }
561 :
562 1 : CPPUNIT_ASSERT( nownum++ == *i );
563 :
564 2 : CPPUNIT_ASSERT(nownum == maxnum);
565 : }
566 :
567 : { // test const_reverse_iterator prefix++
568 1 : unsigned int nownum = maxnum;
569 :
570 2003 : for(btree_type::const_reverse_iterator i = set.rbegin();
571 : i != set.rend(); ++i)
572 : {
573 1000 : CPPUNIT_ASSERT( --nownum == *i );
574 : }
575 :
576 1 : CPPUNIT_ASSERT(nownum == 0);
577 : }
578 :
579 : { // test const_reverse_iterator prefix--
580 1 : unsigned int nownum = 0;
581 :
582 1 : btree_type::const_reverse_iterator i;
583 2001 : for(i = --set.rend(); i != set.rbegin(); --i)
584 : {
585 999 : CPPUNIT_ASSERT( nownum++ == *i );
586 : }
587 :
588 1 : CPPUNIT_ASSERT( nownum++ == *i );
589 :
590 2 : CPPUNIT_ASSERT(nownum == maxnum);
591 : }
592 :
593 : // postfix
594 :
595 : { // test iterator postfix++
596 1 : unsigned int nownum = 0;
597 :
598 2003 : for(btree_type::iterator i = set.begin();
599 : i != set.end(); i++)
600 : {
601 1000 : CPPUNIT_ASSERT( nownum++ == *i );
602 : }
603 :
604 1 : CPPUNIT_ASSERT(nownum == maxnum);
605 : }
606 :
607 : { // test iterator postfix--
608 1 : unsigned int nownum = maxnum;
609 :
610 1 : btree_type::iterator i;
611 2001 : for(i = --set.end(); i != set.begin(); i--)
612 : {
613 :
614 999 : CPPUNIT_ASSERT( --nownum == *i );
615 : }
616 :
617 1 : CPPUNIT_ASSERT( --nownum == *i );
618 :
619 2 : CPPUNIT_ASSERT(nownum == 0);
620 : }
621 :
622 : { // test const_iterator postfix++
623 1 : unsigned int nownum = 0;
624 :
625 2003 : for(btree_type::const_iterator i = set.begin();
626 : i != set.end(); i++)
627 : {
628 1000 : CPPUNIT_ASSERT( nownum++ == *i );
629 : }
630 :
631 1 : CPPUNIT_ASSERT(nownum == maxnum);
632 : }
633 :
634 : { // test const_iterator postfix--
635 1 : unsigned int nownum = maxnum;
636 :
637 1 : btree_type::const_iterator i;
638 2001 : for(i = --set.end(); i != set.begin(); i--)
639 : {
640 999 : CPPUNIT_ASSERT( --nownum == *i );
641 : }
642 :
643 1 : CPPUNIT_ASSERT( --nownum == *i );
644 :
645 2 : CPPUNIT_ASSERT(nownum == 0);
646 : }
647 :
648 : { // test reverse_iterator postfix++
649 1 : unsigned int nownum = maxnum;
650 :
651 2003 : for(btree_type::reverse_iterator i = set.rbegin();
652 : i != set.rend(); i++)
653 : {
654 1000 : CPPUNIT_ASSERT( --nownum == *i );
655 : }
656 :
657 1 : CPPUNIT_ASSERT(nownum == 0);
658 : }
659 :
660 : { // test reverse_iterator postfix--
661 1 : unsigned int nownum = 0;
662 :
663 1 : btree_type::reverse_iterator i;
664 2001 : for(i = --set.rend(); i != set.rbegin(); i--)
665 : {
666 999 : CPPUNIT_ASSERT( nownum++ == *i );
667 : }
668 :
669 1 : CPPUNIT_ASSERT( nownum++ == *i );
670 :
671 2 : CPPUNIT_ASSERT(nownum == maxnum);
672 : }
673 :
674 : { // test const_reverse_iterator postfix++
675 1 : unsigned int nownum = maxnum;
676 :
677 2003 : for(btree_type::const_reverse_iterator i = set.rbegin();
678 : i != set.rend(); i++)
679 : {
680 1000 : CPPUNIT_ASSERT( --nownum == *i );
681 : }
682 :
683 1 : CPPUNIT_ASSERT(nownum == 0);
684 : }
685 :
686 : { // test const_reverse_iterator postfix--
687 1 : unsigned int nownum = 0;
688 :
689 1 : btree_type::const_reverse_iterator i;
690 2001 : for(i = --set.rend(); i != set.rbegin(); i--)
691 : {
692 999 : CPPUNIT_ASSERT( nownum++ == *i );
693 : }
694 :
695 1 : CPPUNIT_ASSERT( nownum++ == *i );
696 :
697 2 : CPPUNIT_ASSERT(nownum == maxnum);
698 1 : }
699 1 : }
700 :
701 1 : void test_iterator5()
702 : {
703 : typedef stx::btree_set<unsigned int,
704 : std::less<unsigned int>, struct traits_nodebug> btree_type;
705 :
706 1 : btree_type set;
707 :
708 1 : unsigned int maxnum = 100;
709 :
710 101 : for(unsigned int i = 0; i < maxnum; ++i)
711 : {
712 100 : set.insert(i);
713 : }
714 :
715 : {
716 1 : btree_type::iterator it;
717 :
718 1 : it = set.begin();
719 1 : it--;
720 1 : CPPUNIT_ASSERT( it == set.begin() );
721 :
722 1 : it = set.begin();
723 1 : --it;
724 1 : CPPUNIT_ASSERT( it == set.begin() );
725 :
726 1 : it = set.end();
727 1 : it++;
728 1 : CPPUNIT_ASSERT( it == set.end() );
729 :
730 1 : it = set.end();
731 1 : ++it;
732 1 : CPPUNIT_ASSERT( it == set.end() );
733 : }
734 :
735 : {
736 1 : btree_type::const_iterator it;
737 :
738 2 : it = set.begin();
739 1 : it--;
740 1 : CPPUNIT_ASSERT( it == set.begin() );
741 :
742 2 : it = set.begin();
743 1 : --it;
744 1 : CPPUNIT_ASSERT( it == set.begin() );
745 :
746 2 : it = set.end();
747 1 : it++;
748 1 : CPPUNIT_ASSERT( it == set.end() );
749 :
750 2 : it = set.end();
751 1 : ++it;
752 1 : CPPUNIT_ASSERT( it == set.end() );
753 : }
754 :
755 : {
756 1 : btree_type::reverse_iterator it;
757 :
758 1 : it = set.rbegin();
759 1 : it--;
760 1 : CPPUNIT_ASSERT( it == set.rbegin() );
761 :
762 1 : it = set.rbegin();
763 1 : --it;
764 1 : CPPUNIT_ASSERT( it == set.rbegin() );
765 :
766 1 : it = set.rend();
767 1 : it++;
768 1 : CPPUNIT_ASSERT( it == set.rend() );
769 :
770 1 : it = set.rend();
771 1 : ++it;
772 1 : CPPUNIT_ASSERT( it == set.rend() );
773 : }
774 :
775 : {
776 1 : btree_type::const_reverse_iterator it;
777 :
778 2 : it = set.rbegin();
779 1 : it--;
780 1 : CPPUNIT_ASSERT( it == set.rbegin() );
781 :
782 2 : it = set.rbegin();
783 1 : --it;
784 1 : CPPUNIT_ASSERT( it == set.rbegin() );
785 :
786 2 : it = set.rend();
787 1 : it++;
788 1 : CPPUNIT_ASSERT( it == set.rend() );
789 :
790 2 : it = set.rend();
791 1 : ++it;
792 1 : CPPUNIT_ASSERT( it == set.rend() );
793 1 : }
794 1 : }
795 : };
796 0 :
797 3 : CPPUNIT_TEST_SUITE_REGISTRATION( IteratorTest );
|
