?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Changes to attempt to silence bcc64x
[ACE_TAO.git] / ACE / tests / Map_Manager_Test.cpp
blobd55135235f70909254829d680610658a096ef292
1
2 //=============================================================================
3 /**
4 * @file Map_Manager_Test.cpp
5 *
6 * This is a simple test of the <ACE_Map_Manager> and
7 * <ACE_Hash_Map_Manager> that illustrates how to use the forward
8 * and reverse iterators.
9 *
10 * @author Irfan Pyarali <irfan@cs.wustl.edu>
11 * @author Douglas C. Schmidt <d.schmidt@vanderbilt.edu>
12 * @author and Kirthika Parameswaran <kirthika@cs.wustl.edu>
13 */
14 //=============================================================================
15
16
17 #include "test_config.h"
18 #include "ace/Map_Manager.h"
19 #include "ace/Hash_Map_Manager.h"
20 #include "ace/Active_Map_Manager.h"
21 #include "ace/Profile_Timer.h"
22 #include "ace/Hash_Cache_Map_Manager_T.h"
23 #include "ace/Caching_Strategies_T.h"
24
25 using MUTEX = ACE_Null_Mutex;
26 using TYPE = ACE_UINT32;
27 using ACTIVE_KEY = ACE_Active_Map_Manager_Key;
28 using HASH_KEY = ACE_Hash<TYPE>;
29 using COMPARE_KEYS = ACE_Equal_To<TYPE>;
30
31 using MAP_MANAGER = ACE_Map_Manager<TYPE, TYPE, MUTEX>;
32 using ITERATOR = ACE_Map_Iterator<TYPE, TYPE, MUTEX>;
33 using REVERSE_ITERATOR = ACE_Map_Reverse_Iterator<TYPE, TYPE, MUTEX>;
34 using MAP_ENTRY = ACE_Map_Entry<TYPE, TYPE>;
35 using HASH_MAP_MANAGER = ACE_Hash_Map_Manager_Ex<TYPE, TYPE, HASH_KEY, COMPARE_KEYS, MUTEX>;
36 using HASH_ITERATOR = ACE_Hash_Map_Iterator_Ex<TYPE, TYPE, HASH_KEY, COMPARE_KEYS, MUTEX>;
37 using HASH_REVERSE_ITERATOR = ACE_Hash_Map_Reverse_Iterator_Ex<TYPE, TYPE, HASH_KEY, COMPARE_KEYS, MUTEX>;
38 using HASH_ENTRY = ACE_Hash_Map_Entry<TYPE, TYPE>;
39 using ACTIVE_MAP_MANAGER = ACE_Active_Map_Manager<TYPE>;
40
41 using CACHE_MAP_IMPL = ACE_Hash_Map_Manager_Ex<TYPE, std::pair<TYPE, int>, HASH_KEY, COMPARE_KEYS, MUTEX>;
42 using CACHE_ITER_IMPL = ACE_Hash_Map_Iterator_Ex<TYPE, std::pair<TYPE, int>, HASH_KEY, COMPARE_KEYS, MUTEX>;
43 using CACHE_REV_ITER_IMPL = ACE_Hash_Map_Reverse_Iterator_Ex<TYPE, std::pair<TYPE, int>, HASH_KEY, COMPARE_KEYS, MUTEX>;
44 using ATTR = int;
45 using NULL_CLEANUP = ANCLE<TYPE, TYPE, CACHE_MAP_IMPL>;
46 using NULL_UTILITY = ACE_Null_Caching_Utility<TYPE, TYPE, CACHE_MAP_IMPL, CACHE_ITER_IMPL, ATTR>;
47 using NULL_CACHING_STRATEGY = ANULL<ATTR, NULL_UTILITY>;
48 using CACHE_MAP_MANAGER = ACMM<TYPE, TYPE, CACHE_MAP_IMPL, CACHE_ITER_IMPL, CACHE_REV_ITER_IMPL, NULL_CACHING_STRATEGY, ATTR>;
49 using HASH_CACHE_MAP_MANAGER = ACE_Hash_Cache_Map_Manager<TYPE, TYPE, HASH_KEY, COMPARE_KEYS, NULL_CACHING_STRATEGY, ATTR>;
50
51 static int
52 test_cache_map_manager (size_t table_size,
53 size_t iterations,
54 int test_iterators)
55 {
56 NULL_CACHING_STRATEGY null_caching_strategy;
57 CACHE_MAP_MANAGER map (null_caching_strategy,
58 table_size);
59 TYPE i;
60 TYPE j = TYPE ();
61 ssize_t k;
62
63 for (i = 0; i < iterations; i++)
64 ACE_TEST_ASSERT (map.bind (i, i) != -1);
65
66 if (test_iterators)
67 {
68 {
69 i = 0;
70
71 CACHE_MAP_MANAGER::ITERATOR end = map.end ();
72
73 for (CACHE_MAP_MANAGER::ITERATOR iter = map.begin ();
74 iter != end;
75 ++iter)
76 {
77 ACE_DEBUG ((LM_DEBUG,
78 ACE_TEXT ("(%d|%d|%d)"),
79 i,
80 (*iter).first (),
81 (*iter).second ()));
82 ++i;
83 }
84
85 ACE_DEBUG ((LM_DEBUG,
86 ACE_TEXT ("\n")));
87 ACE_TEST_ASSERT (i == iterations);
88 }
89
90
91 {
92 k = iterations - 1;
93
94 CACHE_MAP_MANAGER::REVERSE_ITERATOR rend = map.rend ();
95
96 for (CACHE_MAP_MANAGER::REVERSE_ITERATOR iter = map.rbegin ();
97 iter != rend;
98 ++iter)
99 {
100 ACE_DEBUG ((LM_DEBUG,
101 ACE_TEXT ("(%d|%d|%d)"),
102 k,
103 (*iter).first (),
104 (*iter).second ()));
105 k--;
106 }
107
108 ACE_DEBUG ((LM_DEBUG,
109 ACE_TEXT ("\n")));
110 ACE_TEST_ASSERT (k == -1);
111 }
112
113
114 {
115 i = 0;
116
117 CACHE_MAP_MANAGER::iterator end = map.end ();
118
119 for (CACHE_MAP_MANAGER::iterator iter = map.begin ();
120 iter != end;
121 ++iter)
122 {
123 ACE_DEBUG ((LM_DEBUG,
124 ACE_TEXT ("(%d|%d|%d)"),
125 i,
126 (*iter).first (),
127 (*iter).second ()));
128 ++i;
129 }
130
131 ACE_DEBUG ((LM_DEBUG,
132 ACE_TEXT ("\n")));
133 ACE_TEST_ASSERT (i == iterations);
134 }
135
136
137 {
138 k = iterations - 1;
139
140 CACHE_MAP_MANAGER::reverse_iterator rend = map.rend ();
141
142 for (CACHE_MAP_MANAGER::reverse_iterator iter = map.rbegin ();
143 iter != rend;
144 ++iter)
145 {
146 ACE_DEBUG ((LM_DEBUG,
147 ACE_TEXT ("(%d|%d|%d)"),
148 k,
149 (*iter).first (),
150 (*iter).second ()));
151 k--;
152 }
153
154 ACE_DEBUG ((LM_DEBUG,
155 ACE_TEXT ("\n")));
156 ACE_TEST_ASSERT (k == -1);
157 }
158
159
160 }
161
162 for (i = 0; i < iterations; ++i)
163 {
164 ACE_TEST_ASSERT (map.find (i, j) != -1);
165 ACE_TEST_ASSERT (i == j);
166 }
167
168 size_t remaining_entries = iterations;
169 for (i = 0; i < iterations; ++i)
170 {
171 ACE_TEST_ASSERT (map.unbind (i) != -1);
172 --remaining_entries;
173 ACE_TEST_ASSERT (map.current_size () == remaining_entries);
174 }
175
176 return 0;
177 }
178
179 static int
180 test_hash_cache_map_manager (size_t table_size,
181 size_t iterations,
182 int test_iterators)
183 {
184 NULL_CACHING_STRATEGY null_caching_strategy;
185 HASH_CACHE_MAP_MANAGER map (null_caching_strategy,
186 table_size);
187 TYPE i;
188 TYPE j = 0;
189 ssize_t k;
190
191 for (i = 0; i < iterations; i++)
192 ACE_TEST_ASSERT (map.bind (i, i) != -1);
193
194 if (test_iterators)
195 {
196 {
197 i = 0;
198
199 HASH_CACHE_MAP_MANAGER::ITERATOR end = map.end ();
200
201 for (HASH_CACHE_MAP_MANAGER::ITERATOR iter = map.begin ();
202 iter != end;
203 ++iter)
204 {
205 ACE_DEBUG ((LM_DEBUG,
206 ACE_TEXT ("(%d|%d|%d)"),
207 i,
208 (*iter).first (),
209 (*iter).second ()));
210 ++i;
211 }
212
213 ACE_DEBUG ((LM_DEBUG,
214 ACE_TEXT ("\n")));
215 ACE_TEST_ASSERT (i == iterations);
216 }
217
218
219 {
220 k = iterations - 1;
221
222 HASH_CACHE_MAP_MANAGER::REVERSE_ITERATOR rend = map.rend ();
223
224 for (HASH_CACHE_MAP_MANAGER::REVERSE_ITERATOR iter = map.rbegin ();
225 iter != rend;
226 ++iter)
227 {
228 ACE_DEBUG ((LM_DEBUG,
229 ACE_TEXT ("(%d|%d|%d)"),
230 k,
231 (*iter).first (),
232 (*iter).second ()));
233 k--;
234 }
235
236 ACE_DEBUG ((LM_DEBUG,
237 ACE_TEXT ("\n")));
238 ACE_TEST_ASSERT (k == -1);
239 }
240
241
242 {
243 i = 0;
244
245 HASH_CACHE_MAP_MANAGER::iterator end = map.end ();
246
247 for (HASH_CACHE_MAP_MANAGER::iterator iter = map.begin ();
248 iter != end;
249 ++iter)
250 {
251 ACE_DEBUG ((LM_DEBUG,
252 ACE_TEXT ("(%d|%d|%d)"),
253 i,
254 (*iter).first (),
255 (*iter).second ()));
256 ++i;
257 }
258
259 ACE_DEBUG ((LM_DEBUG,
260 ACE_TEXT ("\n")));
261 ACE_TEST_ASSERT (i == iterations);
262 }
263
264
265 {
266 k = iterations - 1;
267
268 HASH_CACHE_MAP_MANAGER::reverse_iterator rend = map.rend ();
269
270 for (HASH_CACHE_MAP_MANAGER::reverse_iterator iter = map.rbegin ();
271 iter != rend;
272 ++iter)
273 {
274 ACE_DEBUG ((LM_DEBUG,
275 ACE_TEXT ("(%d|%d|%d)"),
276 k,
277 (*iter).first (),
278 (*iter).second ()));
279 k--;
280 }
281
282 ACE_DEBUG ((LM_DEBUG,
283 ACE_TEXT ("\n")));
284 ACE_TEST_ASSERT (k == -1);
285 }
286
287
288 }
289
290 for (i = 0; i < iterations; ++i)
291 {
292 ACE_TEST_ASSERT (map.find (i, j) != -1);
293 ACE_TEST_ASSERT (i == j);
294 }
295
296 size_t remaining_entries = iterations;
297 for (i = 0; i < iterations; ++i)
298 {
299 ACE_TEST_ASSERT (map.unbind (i) != -1);
300 --remaining_entries;
301 ACE_TEST_ASSERT (map.current_size () == remaining_entries);
302 }
303 return 0;
304 }
305
306
307 static int
308 test_active_map_manager (size_t table_size,
309 size_t iterations,
310 int test_iterators)
311 {
312 ACTIVE_MAP_MANAGER map (table_size);
313 TYPE i;
314 TYPE j = 0;
315 ssize_t k;
316
317 ACTIVE_MAP_MANAGER::key_type *active_keys;
318
319 ACE_NEW_RETURN (active_keys,
320 ACTIVE_MAP_MANAGER::key_type[iterations],
321 1);
322
323 for (i = 0;
324 i < iterations;
325 i++)
326 ACE_TEST_ASSERT (map.bind (i, active_keys[i]) != -1);
327
328 if (test_iterators)
329 {
330 {
331 i = 0;
332
333 ACTIVE_MAP_MANAGER::iterator end = map.end ();
334
335 for (ACTIVE_MAP_MANAGER::iterator iter = map.begin ();
336 iter != end;
337 ++iter)
338 {
339 ACTIVE_MAP_MANAGER::ENTRY &entry = *iter;
340 ACE_DEBUG ((LM_DEBUG,
341 ACE_TEXT ("(%d|%d-%d|%d)"),
342 i,
343 entry.ext_id_.slot_index (),
344 entry.ext_id_.slot_generation (),
345 entry.int_id_));
346 ++i;
347 }
348
349 ACE_DEBUG ((LM_DEBUG,
350 ACE_TEXT ("\n")));
351 ACE_TEST_ASSERT (i == iterations);
352 }
353
354 {
355 k = iterations - 1;
356
357 ACTIVE_MAP_MANAGER::reverse_iterator rend = map.rend ();
358
359 for (ACTIVE_MAP_MANAGER::reverse_iterator iter = map.rbegin ();
360 iter != rend;
361 ++iter)
362 {
363 ACTIVE_MAP_MANAGER::ENTRY &entry = *iter;
364 ACE_UNUSED_ARG (entry);
365 ACE_DEBUG ((LM_DEBUG,
366 ACE_TEXT ("(%d|%d-%d|%d)"),
367 k,
368 entry.ext_id_.slot_index (),
369 entry.ext_id_.slot_generation (),
370 entry.int_id_));
371 k--;
372 }
373
374 ACE_DEBUG ((LM_DEBUG,
375 ACE_TEXT ("\n")));
376 ACE_TEST_ASSERT (k == -1);
377 }
378 }
379
380 for (i = 0; i < iterations; ++i)
381 {
382 ACE_TEST_ASSERT (map.find (active_keys[i], j) != -1);
383 ACE_TEST_ASSERT (i == j);
384 }
385
386 size_t remaining_entries = iterations;
387 for (i = 0; i < iterations; ++i)
388 {
389 ACE_TEST_ASSERT (map.unbind (active_keys[i]) != -1);
390 --remaining_entries;
391 ACE_TEST_ASSERT (map.current_size () == remaining_entries);
392 }
393
394 delete [] active_keys;
395
396 return 0;
397 }
398
399 static int
400 test_hash_map_manager (size_t table_size,
401 size_t iterations,
402 int test_iterators)
403 {
404 HASH_MAP_MANAGER map (table_size);
405 TYPE i;
406 TYPE j = 0;
407 ssize_t k;
408
409 for (i = 0; i < iterations; i++)
410 ACE_TEST_ASSERT (map.bind (i, i) != -1);
411
412 if (test_iterators)
413 {
414 {
415 i = 0;
416
417 HASH_ITERATOR end = map.end ();
418 for (HASH_ITERATOR iter = map.begin ();
419 iter != end;
420 ++iter)
421 {
422 HASH_ENTRY &entry = *iter;
423 ACE_DEBUG ((LM_DEBUG,
424 ACE_TEXT ("(%d|%d|%d)"),
425 i,
426 entry.ext_id_,
427 entry.int_id_));
428 ++i;
429 }
430
431 ACE_DEBUG ((LM_DEBUG,
432 ACE_TEXT ("\n")));
433 ACE_TEST_ASSERT (i == iterations);
434 }
435
436 {
437 i = 0;
438 HASH_ENTRY *entry = 0;
439
440 for (HASH_ITERATOR iterator (map);
441 iterator.next (entry) != 0;
442 iterator.advance ())
443 {
444 ACE_DEBUG ((LM_DEBUG,
445 ACE_TEXT ("(%d|%d|%d)"),
446 i,
447 entry->ext_id_,
448 entry->int_id_));
449 ++i;
450 }
451
452 ACE_DEBUG ((LM_DEBUG,
453 ACE_TEXT ("\n")));
454 ACE_TEST_ASSERT (i == iterations);
455 }
456
457 {
458 k = iterations - 1;
459 HASH_REVERSE_ITERATOR rend = map.rend ();
460
461 for (HASH_REVERSE_ITERATOR iter = map.rbegin ();
462 iter != rend;
463 ++iter)
464 {
465 HASH_ENTRY &entry = *iter;
466 ACE_DEBUG ((LM_DEBUG,
467 ACE_TEXT ("(%d|%d|%d)"),
468 k,
469 entry.ext_id_,
470 entry.int_id_));
471 k--;
472 }
473
474 ACE_DEBUG ((LM_DEBUG,
475 ACE_TEXT ("\n")));
476 ACE_TEST_ASSERT (k == -1);
477 }
478
479 {
480 k = iterations - 1;
481 HASH_ENTRY *entry = 0;
482
483 for (HASH_REVERSE_ITERATOR iterator (map);
484 iterator.next (entry) != 0;
485 iterator.advance ())
486 {
487 ACE_DEBUG ((LM_DEBUG,
488 ACE_TEXT ("(%d|%d|%d)"),
489 k,
490 entry->ext_id_,
491 entry->int_id_));
492 k--;
493 }
494
495 ACE_DEBUG ((LM_DEBUG,
496 ACE_TEXT ("\n")));
497 ACE_TEST_ASSERT (k == -1);
498 }
499
500 {
501 i = 0;
502
503 HASH_MAP_MANAGER::iterator end = map.end ();
504 for (HASH_MAP_MANAGER::iterator iter = map.begin ();
505 iter != end;
506 ++iter)
507 {
508 HASH_MAP_MANAGER::ENTRY &entry = *iter;
509 ACE_DEBUG ((LM_DEBUG,
510 ACE_TEXT ("(%d|%d|%d)"),
511 i,
512 entry.ext_id_,
513 entry.int_id_));
514 ++i;
515 }
516
517 ACE_DEBUG ((LM_DEBUG,
518 ACE_TEXT ("\n")));
519 ACE_TEST_ASSERT (i == iterations);
520 }
521
522 {
523 i = 0;
524 HASH_MAP_MANAGER::ENTRY *entry = 0;
525
526 for (HASH_MAP_MANAGER::ITERATOR iterator (map);
527 iterator.next (entry) != 0;
528 iterator.advance ())
529 {
530 ACE_DEBUG ((LM_DEBUG,
531 ACE_TEXT ("(%d|%d|%d)"),
532 i,
533 entry->ext_id_,
534 entry->int_id_));
535 ++i;
536 }
537
538 ACE_DEBUG ((LM_DEBUG,
539 ACE_TEXT ("\n")));
540 ACE_TEST_ASSERT (i == iterations);
541 }
542
543 {
544 k = iterations - 1;
545 HASH_MAP_MANAGER::reverse_iterator rend = map.rend ();
546
547 for (HASH_MAP_MANAGER::reverse_iterator iter = map.rbegin ();
548 iter != rend;
549 ++iter)
550 {
551 HASH_MAP_MANAGER::ENTRY &entry = *iter;
552 ACE_DEBUG ((LM_DEBUG,
553 ACE_TEXT ("(%d|%d|%d)"),
554 k,
555 entry.ext_id_,
556 entry.int_id_));
557 k--;
558 }
559
560 ACE_DEBUG ((LM_DEBUG,
561 ACE_TEXT ("\n")));
562 ACE_TEST_ASSERT (k == -1);
563 }
564
565 {
566 k = iterations - 1;
567 HASH_MAP_MANAGER::ENTRY *entry = 0;
568
569 for (HASH_MAP_MANAGER::REVERSE_ITERATOR iterator (map);
570 iterator.next (entry) != 0;
571 iterator.advance ())
572 {
573 ACE_DEBUG ((LM_DEBUG,
574 ACE_TEXT ("(%d|%d|%d)"),
575 k,
576 entry->ext_id_,
577 entry->int_id_));
578 k--;
579 }
580
581 ACE_DEBUG ((LM_DEBUG,
582 ACE_TEXT ("\n")));
583 ACE_TEST_ASSERT (k == -1);
584 }
585 }
586
587 for (i = 0; i < iterations; ++i)
588 {
589 ACE_TEST_ASSERT (map.find (i, j) != -1);
590 ACE_TEST_ASSERT (i == j);
591 }
592
593 size_t remaining_entries = iterations;
594 for (i = 0; i < iterations; ++i)
595 {
596 ACE_TEST_ASSERT (map.unbind (i) != -1);
597 --remaining_entries;
598 ACE_TEST_ASSERT (map.current_size () == remaining_entries);
599 }
600
601 return 0;
602 }
603
604 static int
605 test_map_manager (size_t table_size,
606 size_t iterations,
607 int test_iterators)
608 {
609 MAP_MANAGER map (table_size);
610 TYPE i;
611 TYPE j = 0;
612 ssize_t k;
613
614 for (i = 0; i < iterations; ++i)
615 ACE_TEST_ASSERT (map.bind (i, i) != -1);
616
617 if (test_iterators)
618 {
619 {
620 i = 0;
621
622 ITERATOR end = map.end ();
623 for (ITERATOR iter = map.begin ();
624 iter != end;
625 ++iter)
626 {
627 MAP_ENTRY &entry = *iter;
628 ACE_DEBUG ((LM_DEBUG,
629 ACE_TEXT ("(%d|%d|%d)"),
630 i,
631 entry.ext_id_,
632 entry.int_id_));
633 ++i;
634 }
635
636 ACE_DEBUG ((LM_DEBUG,
637 ACE_TEXT ("\n")));
638 ACE_TEST_ASSERT (i == iterations);
639 }
640
641 {
642 i = 0;
643 MAP_ENTRY *entry = 0;
644
645 for (ITERATOR iterator (map);
646 iterator.next (entry) != 0;
647 iterator.advance ())
648 {
649 ACE_DEBUG ((LM_DEBUG,
650 ACE_TEXT ("(%d|%d|%d)"),
651 i,
652 entry->ext_id_,
653 entry->int_id_));
654 ++i;
655 }
656
657 ACE_DEBUG ((LM_DEBUG,
658 ACE_TEXT ("\n")));
659 ACE_TEST_ASSERT (i == iterations);
660 }
661
662 {
663 k = iterations - 1;
664 REVERSE_ITERATOR rend = map.rend ();
665
666 for (REVERSE_ITERATOR iter = map.rbegin ();
667 iter != rend;
668 ++iter)
669 {
670 MAP_ENTRY &entry = *iter;
671 ACE_DEBUG ((LM_DEBUG,
672 ACE_TEXT ("(%d|%d|%d)"),
673 k,
674 entry.ext_id_,
675 entry.int_id_));
676 k--;
677 }
678
679 ACE_DEBUG ((LM_DEBUG,
680 ACE_TEXT ("\n")));
681 ACE_TEST_ASSERT (k == -1);
682 }
683
684 {
685 k = iterations - 1;
686 MAP_ENTRY *entry = 0;
687
688 for (REVERSE_ITERATOR iterator (map);
689 iterator.next (entry) != 0;
690 iterator.advance ())
691 {
692 ACE_DEBUG ((LM_DEBUG,
693 ACE_TEXT ("(%d|%d|%d)"),
694 k,
695 entry->ext_id_,
696 entry->int_id_));
697 k--;
698 }
699
700 ACE_DEBUG ((LM_DEBUG,
701 ACE_TEXT ("\n")));
702 ACE_TEST_ASSERT (k == -1);
703 }
704
705 {
706 i = 0;
707
708 MAP_MANAGER::iterator end = map.end ();
709 for (MAP_MANAGER::iterator iter = map.begin ();
710 iter != end;
711 ++iter)
712 {
713 MAP_MANAGER::ENTRY &entry = *iter;
714 ACE_DEBUG ((LM_DEBUG,
715 ACE_TEXT ("(%d|%d|%d)"),
716 i,
717 entry.ext_id_,
718 entry.int_id_));
719 ++i;
720 }
721
722 ACE_DEBUG ((LM_DEBUG,
723 ACE_TEXT ("\n")));
724 ACE_TEST_ASSERT (i == iterations);
725 }
726
727 {
728 i = 0;
729 MAP_MANAGER::ENTRY *entry = 0;
730
731 for (MAP_MANAGER::ITERATOR iterator (map);
732 iterator.next (entry) != 0;
733 iterator.advance ())
734 {
735 ACE_DEBUG ((LM_DEBUG,
736 ACE_TEXT ("(%d|%d|%d)"),
737 i,
738 entry->ext_id_,
739 entry->int_id_));
740 ++i;
741 }
742
743 ACE_DEBUG ((LM_DEBUG,
744 ACE_TEXT ("\n")));
745 ACE_TEST_ASSERT (i == iterations);
746 }
747
748 {
749 k = iterations - 1;
750 MAP_MANAGER::reverse_iterator rend = map.rend ();
751
752 for (MAP_MANAGER::reverse_iterator iter = map.rbegin ();
753 iter != rend;
754 ++iter)
755 {
756 MAP_ENTRY &entry = *iter;
757 ACE_DEBUG ((LM_DEBUG,
758 ACE_TEXT ("(%d|%d|%d)"),
759 k,
760 entry.ext_id_,
761 entry.int_id_));
762 k--;
763 }
764
765 ACE_DEBUG ((LM_DEBUG,
766 ACE_TEXT ("\n")));
767 ACE_TEST_ASSERT (k == -1);
768 }
769
770 {
771 k = iterations - 1;
772 MAP_MANAGER::ENTRY *entry = 0;
773
774 for (MAP_MANAGER::REVERSE_ITERATOR iterator (map);
775 iterator.next (entry) != 0;
776 iterator.advance ())
777 {
778 ACE_DEBUG ((LM_DEBUG,
779 ACE_TEXT ("(%d|%d|%d)"),
780 k,
781 entry->ext_id_,
782 entry->int_id_));
783 k--;
784 }
785
786 ACE_DEBUG ((LM_DEBUG,
787 ACE_TEXT ("\n")));
788 ACE_TEST_ASSERT (k == -1);
789 }
790 }
791
792 for (i = 0; i < iterations; ++i)
793 {
794 ACE_TEST_ASSERT (map.find (i, j) != -1);
795 ACE_TEST_ASSERT (i == j);
796 }
797
798 size_t remaining_entries = iterations;
799 for (i = 0; i < iterations; ++i)
800 {
801 ACE_TEST_ASSERT (map.unbind (i) != -1);
802 --remaining_entries;
803 ACE_TEST_ASSERT (map.current_size () == remaining_entries);
804 }
805
806 //
807 // This is extra for the map manager.
808 //
809 for (i = 0; i < iterations; ++i)
810 ACE_TEST_ASSERT (map.bind (i, i) != -1);
811
812 // Unbind in one swoop.
813 map.unbind_all ();
814 ACE_TEST_ASSERT (map.current_size () == 0);
815
816 for (i = 0; i < iterations; ++i)
817 ACE_TEST_ASSERT (map.bind (i, i) != -1);
818
819 // Unbind one at a time.
820 MAP_MANAGER::iterator end = map.end ();
821 while (1)
822 {
823 MAP_MANAGER::iterator iter = map.begin ();
824 if (iter == end)
825 break;
826 ACE_TEST_ASSERT (map.unbind ((*iter).ext_id_) != -1);
827 }
828
829 ACE_TEST_ASSERT (map.current_size () == 0);
830
831 return 0;
832 }
833
834 static int
835 run_test (int (*ptf) (size_t, size_t, int),
836 size_t table_size,
837 size_t iterations,
838 int test_iterators,
839 const ACE_TCHAR *test_name)
840 {
841 ACE_Profile_Timer timer;
842 timer.start ();
843
844 (*ptf) (table_size, iterations, test_iterators);
845
846 timer.stop ();
847
848 ACE_Profile_Timer::ACE_Elapsed_Time et;
849
850 timer.elapsed_time (et);
851
852 ACE_TCHAR *test_iterators_string = 0;
853
854 if (test_iterators)
855 test_iterators_string =
856 const_cast<ACE_TCHAR*> (ACE_TEXT ( "includes executing iterators"));
857 else
858 test_iterators_string =
859 const_cast<ACE_TCHAR*> (ACE_TEXT ("doesn't include executing iterators"));
860
861 ACE_DEBUG ((LM_DEBUG,
862 ACE_TEXT ("time to test a map of size %d for %d iterations using %s (%s)\n"),
863 table_size,
864 iterations,
865 test_name,
866 test_iterators_string));
867
868 ACE_DEBUG ((LM_DEBUG,
869 ACE_TEXT ("real time = %f secs, user time = %f secs, system time = %f secs\n"),
870 et.real_time,
871 et.user_time,
872 et.system_time));
873
874 ACE_timer_t time_result = 0.0;
875 if (iterations != 0)
876 time_result = (et.real_time / ACE_timer_t (iterations)) * 1000000;
877
878 ACE_DEBUG ((LM_DEBUG,
879 ACE_TEXT ("time per call = %f usecs\n"),
880 time_result));
881
882 return 0;
883 }
884
885 int
886 run_main (int argc, ACE_TCHAR *argv[])
887 {
888 ACE_START_TEST (ACE_TEXT ("Map_Manager_Test"));
889 ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE);
890 int result = 0;
891 size_t table_size = ACE_MAX_ITERATIONS / 2;
892 size_t iterations = ACE_MAX_ITERATIONS;
893 int test_iterators = 1;
894
895 if (argc > 1)
896 table_size = ACE_OS::atoi (argv[1]);
897
898 if (argc > 2)
899 iterations = ACE_OS::atoi (argv[2]);
900
901 if (argc > 3)
902 test_iterators = ACE_OS::atoi (argv[3]);
903
904 if (table_size == 0)
905 {
906 ACE_ERROR ((LM_ERROR, "LM_ERROR@Table size is 0\n"));
907 ++result;
908 }
909 else
910 {
911 // Test the <ACE_Map_Manager>.
912 result += run_test (&test_map_manager,
913 table_size,
914 iterations,
915 test_iterators,
916 ACE_TEXT ("Map_Manager"));
917
918 // Test the <ACE_Hash_Map_Manager>.
919 result += run_test (&test_hash_map_manager,
920 table_size,
921 iterations,
922 test_iterators,
923 ACE_TEXT ("Hash_Map_Manager"));
924
925 // Test the <ACE_Hash_Map_Manager>.
926 result += run_test (&test_active_map_manager,
927 table_size,
928 iterations,
929 test_iterators,
930 ACE_TEXT ("Active_Map_Manager"));
931
932 // Test the <ACE_Cache_Map_Manager>.
933 result += run_test (&test_cache_map_manager,
934 table_size,
935 iterations,
936 test_iterators,
937 ACE_TEXT ("Cache_Map_Manager"));
938
939 // Test the <ACE_Hash_Cache_Map_Manager>.
940 result += run_test (&test_hash_cache_map_manager,
941 table_size,
942 iterations,
943 test_iterators,
944 ACE_TEXT ("Hash_Cache_Map_Manager"));
945 }
946 ACE_LOG_MSG->set_flags (ACE_Log_Msg::VERBOSE_LITE);
947 ACE_END_TEST;
948 return result;
949 }
950