ACE/tests/SString_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    SString_Test.cpp
   5  *
   6  *    This is a simple test that illustrates the use of ACE_CString
   7  *    and ACE_WString. No command line arguments are needed to run
   8  *    the test.
   9  *
  10  *  @author Prashant Jain <pjain@cs.wustl.edu>
  11  */
  12 //=============================================================================
  13
  14
  15 #include "test_config.h"
  16 #include "ace/OS_NS_string.h"
  17 #include "ace/Auto_Ptr.h"
  18 #include "ace/SString.h"
  19
  20
  21
  22 static int testConcatenation() {
  23 #ifdef ACE_HAS_WCHAR
  24   ACE_WString s1;
  25   s1 += L'H';
  26   if (s1 != ACE_WString(L"H")) {
  27     ACE_ERROR((LM_ERROR, "Concat wchar_t\n"));
  28     return 1;
  29   }
  30   s1 = ACE_WString(L"Hello");
  31   s1 += L" World";
  32   if (s1 != ACE_WString(L"Hello World")) {
  33     ACE_ERROR((LM_ERROR, "Concat wchar_t*\n"));
  34     return 1;
  35   }
  36   s1 = L"Hello";
  37   s1 += ACE_WString(L" World");
  38   if (s1 != ACE_WString(L"Hello World")) {
  39     ACE_ERROR((LM_ERROR, "Concat wstring\n"));
  40     return 1;
  41   }
  42   s1 = L"Hello";
  43   s1.append(L" World", 6);
  44   if (s1 != ACE_WString(L"Hello World")) {
  45     ACE_ERROR((LM_ERROR, "Concat wchar_t* 2\n"));
  46     return 1;
  47   }
  48   s1 += L'.';
  49   if (s1 != ACE_WString(L"Hello World.")) {
  50     ACE_ERROR((LM_ERROR, "Concat wchar_t\n"));
  51     return 1;
  52   }
  53   ACE_WString s2(L"Hello World");
  54   s2 += L'.';
  55   if (s2 != ACE_WString(L"Hello World.")) {
  56     ACE_ERROR((LM_ERROR, "Concat wchar_t 2\n"));
  57     return 1;
  58   }
  59 #endif /* ACE_HAS_WCHAR */
  60   return 0;
  61 }
  62
  63 int testIterator()
  64 {
  65   ACE_CString s1 ("Hello, World");
  66
  67   // Use the advance () method to count number of characters.
  68   size_t count = 0;
  69   for (ACE_CString::ITERATOR iter (s1); !iter.done (); iter.advance ())
  70     ++ count;
  71
  72   if (count != s1.length ())
  73     ACE_ERROR_RETURN ((LM_ERROR,
  74                        ACE_TEXT ("advance () failed")),
  75                        1);
  76
  77   // Use the prefix operator to count number of characters.
  78   count = 0;
  79   for (ACE_CString::ITERATOR iter (s1); !iter.done (); ++ iter)
  80     ++ count;
  81
  82   if (count != s1.length ())
  83     ACE_ERROR_RETURN ((LM_ERROR,
  84                        ACE_TEXT ("++ operator failed")),
  85                        1);
  86
  87   count = 0;
  88
  89   for (ACE_CString::iterator iter = s1.begin (), iter_end = s1.end ();
  90        iter != iter_end; iter ++)
  91   {
  92     ++ count;
  93   }
  94
  95   if (count != s1.length ())
  96     ACE_ERROR_RETURN ((LM_ERROR,
  97                        ACE_TEXT ("end () failed")),
  98                        1);
  99
 100   ACE_CString::iterator iter1 (s1);
 101
 102   if (*iter1 != s1[0])
 103     ACE_ERROR_RETURN ((LM_ERROR,
 104                        ACE_TEXT ("dereference operator failed")),
 105                        1);
 106
 107   return 0;
 108 }
 109
 110 int testConstIterator()
 111 {
 112   const ACE_CString s1 ("Hello, World");
 113
 114   // Use the advance () method to count number of characters.
 115   size_t count = 0;
 116   for (ACE_CString::CONST_ITERATOR iter (s1); !iter.done (); iter.advance ())
 117     ++ count;
 118
 119   if (count != s1.length ())
 120     ACE_ERROR_RETURN ((LM_ERROR,
 121                        ACE_TEXT ("advance () failed")),
 122                        1);
 123
 124   // Use the prefix operator to count number of characters.
 125   count = 0;
 126   for (ACE_CString::CONST_ITERATOR iter (s1); !iter.done (); ++ iter)
 127     ++ count;
 128
 129   if (count != s1.length ())
 130     ACE_ERROR_RETURN ((LM_ERROR,
 131                        ACE_TEXT ("++ operator failed")),
 132                        1);
 133
 134   count = 0;
 135
 136   for (ACE_CString::const_iterator iter = s1.begin (), iter_end = s1.end ();
 137        iter != iter_end; iter ++)
 138   {
 139     ++ count;
 140   }
 141
 142   if (count != s1.length ())
 143     ACE_ERROR_RETURN ((LM_ERROR,
 144                        ACE_TEXT ("end () failed")),
 145                        1);
 146
 147   ACE_CString::const_iterator iter1 (s1);
 148
 149   if (*iter1 != s1[0])
 150     ACE_ERROR_RETURN ((LM_ERROR,
 151                        ACE_TEXT ("dereference operator failed")),
 152                        1);
 153
 154   return 0;
 155 }
 156
 157
 158 int
 159 run_main (int, ACE_TCHAR *[])
 160 {
 161   ACE_START_TEST (ACE_TEXT ("SString_Test"));
 162
 163   {
 164
 165     /* Set #1 */
 166     ACE_CString s0 ("hello");
 167     ACE_CString s1 ("hello");
 168     ACE_CString s2 ("world");
 169     ACE_CString s3 ("ll");
 170     ACE_CString s4 ("ello");
 171     ACE_CString s5 = s1 + " " + s2;
 172
 173     char single_character = 'z';
 174     ACE_CString single_character_string (single_character);
 175
 176     ACE_CString empty_string;
 177     ACE_CString zero_size_string (s1.c_str (), 0, 0, 1);
 178
 179     if (ACE_CString::npos == 0)
 180       ACE_ERROR((LM_ERROR,"Set #1: npos is incorrect.\n"));
 181
 182     // Not equal comparisons. Error if they are equal
 183     if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 184     if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 185
 186     // Equal comparisons. Error if they are not equal
 187     if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 188     if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 189
 190     // Substring match. Error if they are not equal
 191     if (s1.strstr (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 192     if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 193     if (s3.strstr (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 194     if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 195
 196     // Substring creation. Error if they are not equal
 197     if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 198     if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 199     if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 200     if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 201     if (s1.substring (4, 10).length () != 1){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 202
 203     // Forward search. Error if they are not equal
 204     if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 205     if (s3.find (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 206     if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 207     if (s3.find (s1, 1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 208     if (s1.find (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 209     if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 210
 211     // Reverse search. Error if they are not equal
 212     if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 213     if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 214
 215     // Assignment. Error if they are not equal
 216     ACE_CString s6;
 217     s6 = s0;
 218     if (s6 != s0){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 219     s6 = s4;
 220     if (s4 != s6){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 221     s6 = s5;
 222     if (s6 != s5){ACE_ERROR((LM_ERROR,"Set #1:\n"));return 1;}
 223   }
 224
 225   {
 226     /* Set #2 */
 227     ACE_CString s0 = "hello";
 228     ACE_CString s1 ("hello", 0, false);
 229     ACE_CString s2 ("world", 0, false);
 230     ACE_CString s3 ("ll", 0, false);
 231     ACE_CString s4 ("ello", 0, false);
 232     ACE_CString s5 = s1 + " " + s2;
 233
 234     char single_character = 'z';
 235     ACE_CString single_character_string (single_character);
 236
 237     ACE_CString empty_string (0, 0, false);
 238     ACE_CString zero_size_string (s1.c_str (), 0, 0, false);
 239
 240     // Not equal comparisons. Error if they are equal
 241     if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 242     if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 243
 244     // Equal comparisons. Error if they are not equal
 245     if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 246     if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 247
 248     // Substring match. Error if they are not equal
 249     if (s1.strstr (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 250     if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 251     if (s3.strstr (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 252     if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 253
 254     // Substring creation. Error if they are not equal
 255     if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 256     if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 257     if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 258     if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 259
 260     // Forward search. Error if they are not equal
 261     if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 262     if (s3.find (s1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 263     if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 264     if (s3.find (s1, 1) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 265     if (s1.find (s2) != ACE_CString::npos){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 266     if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 267
 268     // Reverse search. Error if they are not equal
 269     if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 270     if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 271
 272     // Assignment. Error if they are not equal
 273     ACE_CString s6;
 274     s6 = s0;
 275     if (s6 != s0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 276     s6 = s4;
 277     if (s4 != s6){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 278     s6 = s5;
 279     if (s6 != s5){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 280
 281     // Clear. Error if they are not equal
 282     s0.clear();
 283     if (s0.length() != 0){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 284
 285     // Rep. Error if they are not equal
 286     ACE_Auto_Basic_Array_Ptr<char> s (s1.rep ());
 287     if (ACE_OS::strlen (s.get ()) != s1.length ())
 288       {
 289         ACE_ERROR((LM_ERROR,"Auto_ptr s:\n"));
 290       };
 291
 292     ACE_CString s7 (s.get ());
 293     if (s1 != s7){ACE_ERROR((LM_ERROR,"Set #2:\n"));return 1;}
 294   }
 295
 296   {
 297     /* Set #3 */
 298     ACE_NS_WString s0 ("hello");
 299     ACE_NS_WString s1 ("hello");
 300     ACE_NS_WString s2 ("world");
 301     ACE_NS_WString s3 ("ll");
 302     ACE_NS_WString s4 ("ello");
 303     ACE_NS_WString s5 = s1 + " " + s2;
 304     ACE_NS_WString s6 = ("hella"); // Same length as s1, off by one char.
 305
 306     ACE_WCHAR_T single_character = 'z';
 307     ACE_NS_WString single_character_string (single_character);
 308
 309     ACE_NS_WString empty_string;
 310     ACE_NS_WString zero_size_string (s1.c_str (), 0, 0);
 311
 312     // Not equal comparisons. Error if they are equal
 313     if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 314     if (s1 == s5){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 315     if (s1 == s6){ACE_ERROR((LM_ERROR,"Set #3: off-by-one failed\n"));return 1;}
 316
 317     // Equal comparisons. Error if they are not equal
 318     if (s1 != s1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 319     if (s1 != s0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 320
 321     // Substring match. Error if they are not equal
 322     if (s1.strstr (s2) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 323     if (s1.strstr (s3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 324     if (s3.strstr (s1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 325     if (s1.strstr (s4) != 1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 326
 327     // Substring creation. Error if they are not equal
 328     if (s1.substring (0) != s1){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 329     if (s1.substring (1) != s4){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 330     if (s1.substring (2, 2) != s3){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 331     if (s1.substring (0, 0) != empty_string){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 332
 333     // Forward search. Error if they are not equal
 334     if (s1.find (s3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 335     if (s3.find (s1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 336     if (s1.find (s3, 2) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 337     if (s3.find (s1, 1) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 338     if (s1.find (s2) != ACE_NS_WString::npos){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 339     if (s1.find ('o') != 4){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 340
 341     // Reverse search. Error if they are not equal
 342     if (s1.rfind ('l') != 3){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 343     if (s1.rfind ('l', 3) != 2){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 344
 345     // Assignment. Error if they are not equal
 346     ACE_NS_WString s7;
 347     s7 = s0;
 348     if (s7 != s0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 349     s7 = s4;
 350     if (s4 != s7){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 351     s7 = s5;
 352     if (s7 != s5){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 353
 354     // Clear. Error if they are not equal
 355     s0.clear();
 356     if (s0.length() != 0){ACE_ERROR((LM_ERROR,"Set #3:\n"));return 1;}
 357   }
 358
 359   {
 360     /* Set #4 */
 361     ACE_CString s1("dog");
 362     ACE_CString s2("d");
 363
 364     if (s1 == s2){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 365     if (!(s1 > s2)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 366     if (s1 < s2){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 367
 368     ACE_CString s3 ("dog");
 369     ACE_CString s4 ("dogbert");
 370
 371     if (s3 == s4){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 372     if (!(s3 < s4)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 373     if (s3 > s4){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 374
 375     ACE_CString s5 ("dogbert",3);
 376     ACE_CString s6 ("dogbert",5);
 377
 378     if(s5 == s6){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 379     if(!(s5 < s6)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 380     if(s5 > s6){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 381
 382     ACE_CString s7 ("dogbert",4);
 383     ACE_CString s8 ("dogbert",2);
 384
 385     if(s7 == s8){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 386     if(!(s7 > s8)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 387     if(s7 < s8){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 388
 389     ACE_CString s9 ("dogbert",3);
 390     ACE_CString s10 ("dogbert");
 391
 392     if(s9 == s10){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 393     if(!(s9 < s10)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 394     if(s9 > s10){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 395
 396     ACE_CString s11 ("dogbert",5);
 397     ACE_CString s12 ("dog");
 398
 399     if(s11 == s12){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 400     if(!(s11 > s12)){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 401     if(s11 < s12){ACE_ERROR((LM_ERROR,"Set #4:\n"));return 1;}
 402
 403     s11.fast_clear ();
 404     if (s11.length () != 0)
 405       ACE_ERROR ((LM_ERROR, ACE_TEXT ("fast_clear didn't yield 0 length\n")));
 406   }
 407
 408   {
 409     // Set 1 for ACE_SString, which is not tested
 410     ACE_SString sstr;
 411
 412     const char *old = sstr.rep ();
 413     const char *str = "What_a_day_it_has_been";
 414
 415     sstr.rep (const_cast<char *>(str));
 416
 417     ACE_SString tmp =
 418       sstr.substring (2, 300);
 419
 420     if (tmp.length () == 300)
 421       ACE_ERROR ((LM_ERROR, "SString substring\n"));
 422
 423     // Constring an ACE_SString without a character pointer or from an
 424     // existing ACE_SString causes memory to be allocated that will not
 425     // be delete (apparently by design).
 426     ACE_Allocator::instance ()->free (const_cast<char *> (old));
 427     ACE_Allocator::instance ()->free (const_cast<char *> (tmp.rep ()));
 428   }
 429
 430   int err = testConcatenation ();
 431   err += testIterator ();
 432   err += testConstIterator ();
 433
 434   ACE_END_TEST;
 435   return err;
 436 }