ACE/tests/Map_Manager_Test.cpp

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