ACE/tests/Hash_Multi_Map_Manager_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Hash_Multi_Map_Manager_Test.cpp
   5  *
   6  *    This test illustrates the use of <ACE_Hash_Multi_Map_Manager> to
   7  *    maintain a hash table using strings.
   8  *
   9  *  @author Shanshan Jiang <shanshan.jiang@vanderbilt.edu>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "test_config.h"
  15 #include "ace/Hash_Multi_Map_Manager_T.h"
  16 #include "ace/Null_Mutex.h"
  17
  18
  19
  20 using HASH_STRING_MAP = ACE_Hash_Multi_Map_Manager<const ACE_TCHAR *, const ACE_TCHAR *, ACE_Hash<const ACE_TCHAR *>, ACE_Equal_To<const ACE_TCHAR *>, ACE_Null_Mutex>;
  21
  22 using HASH_STRING_ENTRY = HASH_STRING_MAP::ENTRY;
  23 using HASH_STRING_VALUE_SET = HASH_STRING_ENTRY::VALUE_SET;
  24 using HASH_STRING_VALUE_SET_ITERATOR = HASH_STRING_ENTRY::VALUE_SET_ITERATOR;
  25 using HASH_STRING_ITERATOR = HASH_STRING_MAP::ITERATOR;
  26 using HASH_STRING_CONST_ITERATOR = HASH_STRING_MAP::CONST_ITERATOR;
  27 using HASH_STRING_REVERSE_ITERATOR = HASH_STRING_MAP::REVERSE_ITERATOR;
  28
  29 static const ACE_TCHAR *color_sorts[] = {ACE_TEXT ("warm"), ACE_TEXT ("cold"), ACE_TEXT ("neutral"), 0};
  30 static const ACE_TCHAR *warm_colors[] = {ACE_TEXT ("red"), ACE_TEXT ("yellow"), ACE_TEXT ("orange"), 0};
  31 static const ACE_TCHAR *cold_colors[] = {ACE_TEXT ("blue"), ACE_TEXT ("cyan"), 0};
  32 static const ACE_TCHAR *neutral_colors[] = {ACE_TEXT ("green"), ACE_TEXT ("purple"), 0};
  33
  34 static int
  35 run_test ()
  36 {
  37   HASH_STRING_MAP colors;
  38
  39   size_t i;
  40
  41   // Check the <bind> operation.
  42   for (i = 0; warm_colors[i] != 0; i++)
  43     {
  44       if (colors.bind (color_sorts[0],
  45                        warm_colors[i]) == -1)
  46         ACE_ERROR_RETURN ((LM_ERROR,
  47                           ACE_TEXT ("bind failed for %s in %s\n"),
  48                           warm_colors[i],
  49                           color_sorts[0]),
  50                           -1);
  51     }
  52
  53   HASH_STRING_ENTRY *entry = 0;
  54   for (i = 0; cold_colors[i] != 0; i++)
  55     {
  56       if (colors.bind (color_sorts[1],
  57                        cold_colors[i],
  58                        entry) == -1)
  59         ACE_ERROR_RETURN ((LM_ERROR,
  60                           ACE_TEXT ("bind failed for %s in %s\n"),
  61                           cold_colors[i],
  62                           color_sorts[1]),
  63                           -1);
  64     }
  65
  66   HASH_STRING_VALUE_SET value_set;
  67   entry = 0;
  68   for (i = 0; neutral_colors[i] != 0; i++)
  69     value_set.insert (neutral_colors[i]);
  70   if (colors.bind (color_sorts[2],
  71                    value_set,
  72                    entry) == -1)
  73     ACE_ERROR_RETURN ((LM_ERROR,
  74                        ACE_TEXT ("bind failed for %s\n"),
  75                        color_sorts[2]),
  76                        -1);
  77
  78   // Check the <trybind> operation.
  79   value_set.reset ();
  80   if (colors.trybind (color_sorts[2],
  81                       value_set) == -1)
  82     ACE_ERROR_RETURN ((LM_ERROR,
  83                        ACE_TEXT ("bind failed for %s\n"),
  84                        color_sorts[2]),
  85                        -1);
  86
  87   value_set.reset ();
  88   entry = 0;
  89   if (colors.trybind (color_sorts[2],
  90                       value_set,
  91                       entry) == -1)
  92     ACE_ERROR_RETURN ((LM_ERROR,
  93                        ACE_TEXT ("bind failed for %s\n"),
  94                        color_sorts[2]),
  95                        -1);
  96
  97   value_set.reset ();
  98   entry = 0;
  99   if (colors.trybind (color_sorts[2],
 100                       value_set,
 101                       entry) == -1)
 102     ACE_ERROR_RETURN ((LM_ERROR,
 103                        ACE_TEXT ("bind failed for %s\n"),
 104                        color_sorts[2]),
 105                        -1);
 106
 107   // Check the <rebind> operation.
 108   value_set.reset ();
 109   value_set.insert (neutral_colors[0]);
 110   if (colors.rebind (color_sorts[2],
 111                      value_set) == -1)
 112     ACE_ERROR_RETURN ((LM_ERROR,
 113                        ACE_TEXT ("bind failed for %s\n"),
 114                        color_sorts[2]),
 115                        -1);
 116
 117   value_set.reset ();
 118   value_set.insert (neutral_colors[1]);
 119   entry = 0;
 120   if (colors.rebind (color_sorts[2],
 121                      value_set,
 122                      entry) == -1)
 123     ACE_ERROR_RETURN ((LM_ERROR,
 124                        ACE_TEXT ("bind failed for %s\n"),
 125                        color_sorts[2]),
 126                        -1);
 127
 128   value_set.reset ();
 129   value_set.insert (neutral_colors[0]);
 130   HASH_STRING_VALUE_SET old_value_set;
 131   if (colors.rebind (color_sorts[2],
 132                      value_set,
 133                      old_value_set) == -1)
 134     ACE_ERROR_RETURN ((LM_ERROR,
 135                        ACE_TEXT ("bind failed for %s\n"),
 136                        color_sorts[2]),
 137                        -1);
 138
 139   value_set.reset ();
 140   value_set.insert (neutral_colors[1]);
 141   old_value_set.reset ();
 142   entry = 0;
 143   if (colors.rebind (color_sorts[2],
 144                      value_set,
 145                      old_value_set,
 146                      entry) == -1)
 147     ACE_ERROR_RETURN ((LM_ERROR,
 148                        ACE_TEXT ("bind failed for %s\n"),
 149                        color_sorts[2]),
 150                        -1);
 151
 152   value_set.reset ();
 153   value_set.insert (neutral_colors[0]);
 154   const ACE_TCHAR *old_key;
 155   old_value_set.reset ();
 156   if (colors.rebind (color_sorts[2],
 157                      value_set,
 158                      old_key,
 159                      old_value_set) == -1)
 160     ACE_ERROR_RETURN ((LM_ERROR,
 161                        ACE_TEXT ("bind failed for %s\n"),
 162                        color_sorts[2]),
 163                        -1);
 164
 165   value_set.reset ();
 166   for (i = 0; neutral_colors[i] != 0; i++)
 167     value_set.insert (neutral_colors[i]);
 168   old_key = 0;
 169   old_value_set.reset ();
 170   entry = 0;
 171   if (colors.rebind (color_sorts[2],
 172                      value_set,
 173                      old_key,
 174                      old_value_set,
 175                      entry) == -1)
 176     ACE_ERROR_RETURN ((LM_ERROR,
 177                        ACE_TEXT ("bind failed for %s\n"),
 178                        color_sorts[2]),
 179                        -1);
 180
 181   // Check the <find> operation.
 182   for (i = 0; color_sorts[i] != 0; i++)
 183     if (colors.find (color_sorts[i]) == 0)
 184       ACE_DEBUG ((LM_DEBUG,
 185                   ACE_TEXT ("%s found\n"),
 186                   color_sorts[i]));
 187     else
 188       ACE_ERROR_RETURN ((LM_ERROR,
 189                          ACE_TEXT ("%s not found\n"),
 190                          color_sorts[i]),
 191                         -1);
 192
 193   entry = 0;
 194   for (i = 0; color_sorts[i] != 0; i++)
 195     if (colors.find (color_sorts[i],
 196                      entry) == 0)
 197       ACE_DEBUG ((LM_DEBUG,
 198                   ACE_TEXT ("%s found\n"),
 199                   color_sorts[i]));
 200     else
 201       ACE_ERROR_RETURN ((LM_ERROR,
 202                          ACE_TEXT ("%s not found\n"),
 203                          color_sorts[i]),
 204                         -1);
 205
 206   value_set.reset ();
 207   for (i = 0; color_sorts[i] != 0; i++)
 208     if (colors.find (color_sorts[i],
 209                      value_set) == 0)
 210       ACE_DEBUG ((LM_DEBUG,
 211                   ACE_TEXT ("%s found\n"),
 212                   color_sorts[i]));
 213     else
 214       ACE_ERROR_RETURN ((LM_ERROR,
 215                          ACE_TEXT ("%s not found\n"),
 216                          color_sorts[i]),
 217                         -1);
 218
 219   for (i = 0; warm_colors[i] != 0; i++)
 220     if (colors.find (color_sorts[0],
 221                      warm_colors[i]) == 0)
 222       ACE_DEBUG ((LM_DEBUG,
 223                   ACE_TEXT ("%s color %s found\n"),
 224                   color_sorts[0],
 225                   warm_colors[i]));
 226     else
 227       ACE_ERROR_RETURN ((LM_ERROR,
 228                          ACE_TEXT ("%s color %s not found\n"),
 229                          color_sorts[0],
 230                          warm_colors[i]),
 231                         -1);
 232
 233   // Check the iterator.
 234   i = 0;
 235   entry = 0;
 236   for (HASH_STRING_ITERATOR hash_iter (colors);
 237        hash_iter.next (entry) != 0;
 238        hash_iter.advance ())
 239     {
 240       ACE_DEBUG ((LM_DEBUG,
 241                   ACE_TEXT ("iterating (%d): %s:\n"),
 242                   i,
 243                   entry->key ()));
 244       i++;
 245
 246       for (HASH_STRING_VALUE_SET_ITERATOR iter (entry->item ());
 247            iter != entry->item ().end ();
 248            iter++)
 249         {
 250           ACE_DEBUG ((LM_DEBUG,
 251                       ACE_TEXT ("%s \n"),
 252                       *iter));
 253         }
 254     }
 255
 256   // Check the unbind operation.
 257   if (colors.unbind (color_sorts[0]) == -1)
 258     ACE_ERROR_RETURN ((LM_ERROR,
 259                        ACE_TEXT ("unbind failed for %s\n"),
 260                        color_sorts[1]),
 261                       -1);
 262   for (i = 0; warm_colors[i] != 0; i++)
 263     {
 264       if (colors.bind (color_sorts[0],
 265                        warm_colors[i]) == -1)
 266         ACE_ERROR_RETURN ((LM_ERROR,
 267                           ACE_TEXT ("bind failed for %s in %s\n"),
 268                           warm_colors[i],
 269                           color_sorts[0]),
 270                           -1);
 271     }
 272
 273   value_set.reset ();
 274   if (colors.unbind (color_sorts[0], value_set) == -1)
 275     ACE_ERROR_RETURN ((LM_ERROR,
 276                        ACE_TEXT ("unbind failed for %s\n"),
 277                        color_sorts[1]),
 278                       -1);
 279   for (i = 0; warm_colors[i] != 0; i++)
 280     {
 281       if (colors.bind (color_sorts[0],
 282                        warm_colors[i]) == -1)
 283         ACE_ERROR_RETURN ((LM_ERROR,
 284                           ACE_TEXT ("bind failed for %s in %s\n"),
 285                           warm_colors[i],
 286                           color_sorts[0]),
 287                           -1);
 288     }
 289
 290   for (i = 0; warm_colors[i] != 0; i++)
 291     {
 292       if (colors.unbind (color_sorts[0],
 293                          warm_colors[i]) == -1)
 294         ACE_ERROR_RETURN ((LM_ERROR,
 295                            ACE_TEXT ("unbind failed for %s in %s\n"),
 296                            warm_colors[i],
 297                            color_sorts[0]),
 298                           -1);
 299     }
 300
 301   // Check the reverse iterator.
 302   i = 0;
 303   entry = 0;
 304   for (HASH_STRING_REVERSE_ITERATOR hash_iter (colors);
 305        hash_iter.next (entry) != 0;
 306        hash_iter.advance ())
 307     {
 308       ACE_DEBUG ((LM_DEBUG,
 309                   ACE_TEXT ("reverse iterating (%d): %s\n"),
 310                   i,
 311                   entry->key ()));
 312       i++;
 313
 314       for (HASH_STRING_VALUE_SET_ITERATOR iter (entry->item ());
 315            iter != entry->item ().end ();
 316            iter++)
 317         {
 318           ACE_DEBUG ((LM_DEBUG,
 319                       ACE_TEXT ("%s \n"),
 320                       *iter));
 321         }
 322     }
 323
 324   entry = 0;
 325   colors.find (color_sorts[1], entry);
 326   if (colors.unbind (entry) == -1)
 327     ACE_ERROR_RETURN ((LM_ERROR,
 328                        ACE_TEXT ("unbind failed for %s\n"),
 329                        color_sorts[1]),
 330                       -1);
 331
 332   // Check the const iterator.
 333   i = 0;
 334   entry = 0;
 335   for (HASH_STRING_CONST_ITERATOR hash_iter (colors);
 336        hash_iter.next (entry) != 0;
 337        hash_iter.advance ())
 338     {
 339       ACE_DEBUG ((LM_DEBUG,
 340                   ACE_TEXT ("const iterating (%d): %s\n"),
 341                   i,
 342                   entry->key ()));
 343       i++;
 344
 345       for (HASH_STRING_VALUE_SET_ITERATOR iter (entry->item ());
 346            iter != entry->item ().end ();
 347            iter++)
 348         {
 349           ACE_DEBUG ((LM_DEBUG,
 350                       ACE_TEXT ("%s \n"),
 351                       *iter));
 352         }
 353     }
 354
 355   // Check the unbind_all operation.
 356   if (colors.unbind_all () != 0)
 357     ACE_ERROR_RETURN ((LM_ERROR,
 358                        ACE_TEXT ("unbind_all failed\n")),
 359                        -1);
 360
 361   return 0;
 362 }
 363
 364 int
 365 run_main (int, ACE_TCHAR *[])
 366 {
 367   ACE_START_TEST (ACE_TEXT ("Hash_Multi_Map_Manager_Test"));
 368
 369   run_test ();
 370
 371   ACE_END_TEST;
 372
 373   return 0;
 374 }