lib/3rdparty/stlport/test/unit/string_test.cpp

   1 //To make GLib C++ closer to STLport behavior we need this macro:
   2 //Only mandatory when building unit tests without STLport, do not change
   3 //anything when building with STLport
   4 #define _GLIBCXX_FULLY_DYNAMIC_STRING
   5
   6 //Has to be first for StackAllocator swap overload to be taken
   7 //into account (at least using GCC 4.0.1)
   8 #include "stack_allocator.h"
   9
  10 #include <vector>
  11 #include <deque>
  12 #include <string>
  13 #include <algorithm>
  14 #if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
  15 #  include <sstream>
  16 #endif
  17
  18 #if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  19 #  include <stdexcept>
  20 #endif
  21
  22 #if !defined (STLPORT) || defined (_STLP_THREADS)
  23 #  if defined (STLPORT) && defined (_STLP_PTHREADS) || \
  24       defined (__GNUC__) && !defined (__MINGW32__)
  25 #    define USE_PTHREAD_API
  26 #    include <pthread.h>
  27 #  endif
  28
  29 #  if defined (STLPORT) && defined (_STLP_WIN32THREADS) || \
  30       defined (__GNUC__) && defined (__MINGW32__) || \
  31       defined (_MSC_VER)
  32 #    define USE_WINDOWS_API
  33 #    include <windows.h>
  34 #  endif
  35 #endif
  36
  37 #include "stack_allocator.h"
  38 #include "cppunit/cppunit_proxy.h"
  39
  40 #if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
  41 using namespace std;
  42 #endif
  43
  44 //
  45 // TestCase class
  46 //
  47 class StringTest : public CPPUNIT_NS::TestCase
  48 {
  49   CPPUNIT_TEST_SUITE(StringTest);
  50   CPPUNIT_TEST(constructor);
  51   CPPUNIT_TEST(trivial_char_compare);
  52   CPPUNIT_TEST(reserve);
  53   CPPUNIT_TEST(assign);
  54   CPPUNIT_TEST(erase);
  55   CPPUNIT_TEST(data);
  56   CPPUNIT_TEST(c_str);
  57   CPPUNIT_TEST(null_char);
  58   CPPUNIT_TEST(insert);
  59   CPPUNIT_TEST(replace);
  60   CPPUNIT_TEST(resize);
  61   CPPUNIT_TEST(short_string);
  62   CPPUNIT_TEST(find);
  63   CPPUNIT_TEST(bogus_edge_find);
  64   CPPUNIT_TEST(rfind);
  65   CPPUNIT_TEST(find_last_of);
  66   CPPUNIT_TEST(find_last_not_of);
  67   CPPUNIT_TEST(copy);
  68 #if !defined (USE_PTHREAD_API) && !defined (USE_WINDOWS_API)
  69   CPPUNIT_IGNORE;
  70 #endif
  71   CPPUNIT_TEST(mt);
  72   CPPUNIT_STOP_IGNORE;
  73   CPPUNIT_TEST(short_string_optim_bug);
  74   CPPUNIT_TEST(compare);
  75   CPPUNIT_TEST(template_expression);
  76 #if defined (STLPORT) && ((defined (_STLP_MSVC) && (_STLP_MSVC < 1300)) || \
  77    (defined(__GNUC__) && defined(_STLP_USE_TEMPLATE_EXPRESSION) && \
  78     ((__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)) ) )
  79 #  define TE_TMP_TEST_IGNORED
  80   CPPUNIT_IGNORE;
  81 #endif
  82   CPPUNIT_TEST(te_tmp);
  83 #if defined (TE_TMP_TEST_IGNORED)
  84   CPPUNIT_STOP_IGNORE;
  85 #endif
  86   CPPUNIT_TEST(oper_tmp);
  87 #if defined (STLPORT) && defined (_STLP_NO_WCHAR_T)
  88   CPPUNIT_IGNORE;
  89 #endif
  90 #if defined (__CYGWIN__) && !defined (STLPORT)
  91   CPPUNIT_IGNORE;
  92 #endif
  93   CPPUNIT_TEST(template_wexpression);
  94   CPPUNIT_STOP_IGNORE;
  95 #if defined (STLPORT) && defined (_STLP_USE_NO_IOSTREAMS)
  96   CPPUNIT_IGNORE;
  97 #endif
  98   CPPUNIT_TEST(io);
  99   CPPUNIT_STOP_IGNORE;
 100 #if defined (STLPORT) && defined (_STLP_NO_CUSTOM_IO)
 101   CPPUNIT_IGNORE;
 102 #endif
 103   CPPUNIT_TEST(allocator_with_state);
 104   CPPUNIT_STOP_IGNORE;
 105   CPPUNIT_TEST(capacity);
 106   CPPUNIT_TEST(concat24);
 107   CPPUNIT_TEST_SUITE_END();
 108
 109 protected:
 110   void constructor();
 111   void trivial_char_compare();
 112   void reserve();
 113   void erase();
 114   void data();
 115   void c_str();
 116   void null_char();
 117   void insert();
 118   void replace();
 119   void resize();
 120   void short_string();
 121   void find();
 122   void bogus_edge_find();
 123   void rfind();
 124   void find_last_of();
 125   void find_last_not_of();
 126   void copy();
 127   void assign();
 128   void mt();
 129   void short_string_optim_bug();
 130   void compare();
 131   void template_expression();
 132   void te_tmp();
 133   void oper_tmp();
 134   void template_wexpression();
 135   void io();
 136   void allocator_with_state();
 137   void capacity();
 138   void concat24();
 139
 140   static string func(const string& par) {
 141     string tmp( par );
 142     return tmp;
 143   }
 144
 145 #if defined (USE_PTHREAD_API) || defined (USE_WINDOWS_API)
 146 #  if defined (USE_PTHREAD_API)
 147   static void* f(void*)
 148 #  else
 149   static DWORD __stdcall f(void*)
 150 #  endif
 151   {
 152     string s( "qyweyuewunfkHBUKGYUGL,wehbYGUW^(@T@H!BALWD:h^&@#*@(#:JKHWJ:CND" );
 153
 154     for ( int i = 0; i < 2000000; ++i ) {
 155       string sx = func( s );
 156     }
 157
 158     return 0;
 159   }
 160 #endif
 161
 162 };
 163
 164 CPPUNIT_TEST_SUITE_REGISTRATION(StringTest);
 165
 166 //
 167 // tests implementation
 168 //
 169 void StringTest::constructor()
 170 {
 171 #if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
 172   try {
 173     string s((size_t)-1, 'a');
 174     CPPUNIT_FAIL;
 175   }
 176   catch (length_error const&) {
 177   }
 178   catch (...) {
 179     //Expected exception is length_error:
 180     CPPUNIT_FAIL;
 181   }
 182 #endif
 183 }
 184
 185 void StringTest::trivial_char_compare()
 186 {
 187   string s( "message" );
 188
 189   CPPUNIT_CHECK( s == "message" );
 190   CPPUNIT_CHECK( "message" == s );
 191 }
 192
 193 void StringTest::reserve()
 194 {
 195   string s;
 196 #if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
 197   try {
 198     s.reserve(s.max_size() + 1);
 199     CPPUNIT_FAIL;
 200   }
 201   catch (length_error const&) {
 202   }
 203   catch (...) {
 204     //Expected exception is length_error:
 205     CPPUNIT_FAIL;
 206   }
 207 #endif
 208 }
 209
 210 void StringTest::mt()
 211 {
 212 #if defined (USE_PTHREAD_API) || defined (USE_WINDOWS_API)
 213   const int nth = 2;
 214 #  if defined (USE_PTHREAD_API)
 215   pthread_t t[nth];
 216
 217   for ( int i = 0; i < nth; ++i ) {
 218     pthread_create( &t[i], 0, f, 0 );
 219   }
 220
 221   for ( int i = 0; i < nth; ++i ) {
 222     pthread_join( t[i], 0 );
 223   }
 224 #  endif // PTHREAD
 225
 226 #  if defined (USE_WINDOWS_API)
 227   //DWORD start = GetTickCount();
 228
 229   HANDLE t[nth];
 230
 231   int i; // VC6 not support in-loop scope of cycle var
 232   for ( i = 0; i < nth; ++i ) {
 233     t[i] = CreateThread(NULL, 0, f, 0, 0, NULL);
 234   }
 235
 236   if (WaitForMultipleObjects(nth, t, TRUE, INFINITE) == WAIT_FAILED) {
 237     // On some platforms (evc3/evc4) WaitForMultipleObjects() with fWaitAll == TRUE
 238     // is not supported. We then wait with a loop on each thread:
 239     for ( i = 0; i < nth; ++i ) {
 240       WaitForSingleObject(t[i], INFINITE);
 241     }
 242   }
 243
 244   /*
 245   DWORD duration = GetTickCount() - start;
 246   ostringstream ostr;
 247   ostr << "Duration: " << duration << endl;
 248   CPPUNIT_MESSAGE(ostr.str().c_str());
 249   */
 250 #  endif
 251 #endif
 252 }
 253
 254 void StringTest::short_string()
 255 {
 256   string const ref_short_str1("str1"), ref_short_str2("str2");
 257   string short_str1(ref_short_str1), short_str2(ref_short_str2);
 258   string const ref_long_str1("str                                                  1");
 259   string const ref_long_str2("str                                                  2");
 260   string long_str1(ref_long_str1), long_str2(ref_long_str2);
 261
 262   CPPUNIT_ASSERT(short_str1 == ref_short_str1);
 263   CPPUNIT_ASSERT(long_str1 == ref_long_str1);
 264
 265   {
 266     string str1(short_str1);
 267     str1 = long_str1;
 268     CPPUNIT_ASSERT(str1 == ref_long_str1);
 269   }
 270
 271   {
 272     string str1(long_str1);
 273     str1 = short_str1;
 274     CPPUNIT_ASSERT(str1 == ref_short_str1);
 275   }
 276
 277   {
 278     short_str1.swap(short_str2);
 279     CPPUNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1));
 280     short_str1.swap(short_str2);
 281   }
 282
 283   {
 284     long_str1.swap(long_str2);
 285     CPPUNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1));
 286     long_str1.swap(long_str2);
 287   }
 288
 289   {
 290     short_str1.swap(long_str1);
 291     CPPUNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
 292     short_str1.swap(long_str1);
 293   }
 294
 295   {
 296     long_str1.swap(short_str1);
 297     CPPUNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
 298     long_str1.swap(short_str1);
 299   }
 300
 301   {
 302     string a(256, 'a');
 303     string b(256, 'b');
 304     const char* as = a.c_str();
 305     const char* bs = b.c_str();
 306     swap(a, b);
 307     CPPUNIT_ASSERT( a.c_str() == bs );
 308     CPPUNIT_ASSERT( b.c_str() == as );
 309   }
 310
 311   {
 312     //This is to test move constructor
 313     vector<string> str_vect;
 314     str_vect.push_back(short_str1);
 315     str_vect.push_back(long_str1);
 316     str_vect.push_back(short_str2);
 317     str_vect.push_back(long_str2);
 318     CPPUNIT_ASSERT((str_vect[0] == ref_short_str1) &&
 319                    (str_vect[1] == ref_long_str1) &&
 320                    (str_vect[2] == ref_short_str2) &&
 321                    (str_vect[3] == ref_long_str2));
 322   }
 323 }
 324
 325 void StringTest::erase()
 326 {
 327   char const* c_str = "Hello, World!";
 328   string str(c_str);
 329   CPPUNIT_ASSERT( str == c_str );
 330
 331   str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last.
 332
 333   size_t i;
 334   for (i = 0; i < str.size(); ++i) {
 335     switch ( i ) {
 336       case 0:
 337         CPPUNIT_ASSERT( str[i] == 'H' );
 338         break;
 339       case 1:
 340         CPPUNIT_ASSERT( str[i] == '!' );
 341         break;
 342       default:
 343         CPPUNIT_FAIL;
 344     }
 345   }
 346
 347   str.insert(1, c_str);
 348   str.erase(str.begin()); // Erase first element.
 349   str.erase(str.end() - 1); // Erase last element.
 350   CPPUNIT_ASSERT( str == c_str );
 351   str.clear(); // Erase all.
 352   CPPUNIT_ASSERT( str.empty() );
 353
 354   str = c_str;
 355   CPPUNIT_ASSERT( str == c_str );
 356
 357   str.erase(1, str.size() - 1); // Erase all but first and last.
 358   for (i = 0; i < str.size(); i++) {
 359     switch ( i ) {
 360       case 0:
 361         CPPUNIT_ASSERT( str[i] == 'H' );
 362         break;
 363       case 1:
 364         CPPUNIT_ASSERT( str[i] == '!' );
 365         break;
 366       default:
 367         CPPUNIT_FAIL;
 368     }
 369   }
 370
 371   str.erase(1);
 372   CPPUNIT_ASSERT( str == "H" );
 373 }
 374
 375 void StringTest::data()
 376 {
 377   string xx;
 378
 379   CPPUNIT_ASSERT( xx.data() != 0 );  // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3
 380 #if 0
 381   /* This test really not required: in ISO-IEC-14882:1998(E) paragraph 3 stated:
 382    * '... and can have zero added to it', again: 'CAN', but not 'MUST'.
 383    * That's why I am comment this test. But I don't remove it due to I had
 384    * unevident problem with misinterpretation of data() return (i.e. data()
 385    * and c_str() provide different functionality!) and expect that this is
 386    * more-or-less common pitfall.
 387    *    - ptr
 388    */
 389   string low( "2004-01-01" );
 390   // Blocks A and B should follow each other.
 391   // Block A:
 392   xx = "123456";
 393   xx += low;
 394   if ( strcmp( xx.data(), "1234562004-01-01" ) != 0 ) {
 395     return -1;
 396   }
 397   // End of block A
 398
 399   // Block B:
 400   xx = "1234";
 401   xx += ";";
 402
 403   if ( strcmp( xx.data(), "1234;" ) != 0 ) {
 404     return -1;
 405   }
 406   // End of block B
 407 #endif
 408 }
 409
 410 void StringTest::c_str()
 411 {
 412   string low( "2004-01-01" );
 413   string xx;
 414   string yy;
 415
 416   CPPUNIT_ASSERT( *(yy.c_str()) == '\0' ); // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1
 417
 418   // Blocks A and B should follow each other.
 419   // Block A:
 420   xx = "123456";
 421   xx += low;
 422   CPPUNIT_ASSERT( strcmp( xx.c_str(), "1234562004-01-01" ) == 0 );
 423   // End of block A
 424
 425   // Block B:
 426   xx = "1234";
 427   xx += ";";
 428   CPPUNIT_ASSERT( strcmp( xx.c_str(), "1234;" ) == 0 );
 429   // End of block B
 430 }
 431
 432 void StringTest::null_char()
 433 {
 434   // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version')
 435   const string s( "123456" );
 436
 437   CPPUNIT_CHECK( s[s.size()] == '\0' );
 438
 439 #if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
 440   try {
 441     //Check is only here to avoid warning about value of expression not used
 442     CPPUNIT_CHECK( s.at(s.size()) == '\0' );
 443     CPPUNIT_FAIL;
 444   }
 445   catch (out_of_range const&) {
 446     CPPUNIT_ASSERT( true );
 447   }
 448   catch ( ... ) {
 449     CPPUNIT_FAIL;
 450   }
 451 #endif
 452 }
 453
 454 void StringTest::insert()
 455 {
 456   string strorg = "This is test string for string calls";
 457   string str;
 458   /*
 459    * In case of reallocation there is no auto reference problem
 460    * so we reserve a big enough string to be sure to test this
 461    * particular point.
 462    */
 463   str.reserve(100);
 464   str = strorg;
 465
 466   //test self insertion:
 467   str.insert(10, str.c_str() + 5, 15);
 468   CPPUNIT_ASSERT( str == "This is teis test string st string for string calls" );
 469
 470   str = strorg;
 471   str.insert(15, str.c_str() + 5, 25);
 472   CPPUNIT_ASSERT( str == "This is test stis test string for stringring for string calls" );
 473
 474   str = strorg;
 475   str.insert(0, str.c_str() + str.size() - 4, 4);
 476   CPPUNIT_ASSERT( str == "allsThis is test string for string calls" );
 477
 478   str = strorg;
 479   str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1);
 480   CPPUNIT_ASSERT( str == "ng for string callsThis is test string for string calls" );
 481
 482   str = strorg;
 483   string::iterator b = str.begin();
 484   string::const_iterator s = str.begin() + str.size() / 2 - 1;
 485   string::const_iterator e = str.end();
 486   str.insert( b, s, e );
 487   CPPUNIT_ASSERT( str == "ng for string callsThis is test string for string calls" );
 488
 489   str = strorg;
 490   str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end());
 491   CPPUNIT_ASSERT( str == "ng for string callsThis is test string for string calls" );
 492
 493 #ifdef _STLP_MEMBER_TEMPLATES
 494   vector<int> int_vect;
 495   //Just a compile time test:
 496   str.insert(str.end(), int_vect.begin(), int_vect.end());
 497 #endif
 498
 499   string str0;
 500   str0.insert(str0.begin(), 5, '0');
 501   CPPUNIT_ASSERT( str0 == "00000" );
 502
 503   string str1;
 504   {
 505     string::size_type pos = 0, nb = 2;
 506     str1.insert(pos, nb, '1');
 507   }
 508   CPPUNIT_ASSERT( str1 == "11" );
 509
 510   str0.insert(0, str1);
 511   CPPUNIT_ASSERT( str0 == "1100000" );
 512
 513   string str2("2345");
 514   str0.insert(str0.size(), str2, 1, 2);
 515   CPPUNIT_ASSERT( str0 == "110000034" );
 516
 517   str1.insert(str1.begin() + 1, 2, '2');
 518   CPPUNIT_ASSERT( str1 == "1221" );
 519
 520   str1.insert(2, "333333", 3);
 521   CPPUNIT_ASSERT( str1 == "1233321" );
 522
 523   str1.insert(4, "4444");
 524   CPPUNIT_ASSERT( str1 == "12334444321" );
 525
 526   str1.insert(str1.begin() + 6, '5');
 527   CPPUNIT_ASSERT( str1 == "123344544321" );
 528 }
 529
 530 void StringTest::replace()
 531 {
 532   /*
 533    * This test case is for the non template basic_string::replace method,
 534    * this is why we play with the const iterators and reference to guaranty
 535    * that the right method is called.
 536    */
 537   const string v( "78" );
 538   string s( "123456" );
 539   string const& cs = s;
 540
 541   string::iterator i = s.begin() + 1;
 542   s.replace(i, i + 3, v.begin(), v.end());
 543   CPPUNIT_ASSERT( s == "17856" );
 544
 545   s = "123456";
 546   i = s.begin() + 1;
 547   s.replace(i, i + 1, v.begin(), v.end());
 548   CPPUNIT_ASSERT( s == "1783456" );
 549
 550   s = "123456";
 551   i = s.begin() + 1;
 552   string::const_iterator ci = s.begin() + 1;
 553   s.replace(i, i + 3, ci + 3, cs.end());
 554   CPPUNIT_ASSERT( s == "15656" );
 555
 556   s = "123456";
 557   i = s.begin() + 1;
 558   ci = s.begin() + 1;
 559   s.replace(i, i + 3, ci, ci + 2);
 560   CPPUNIT_ASSERT( s == "12356" );
 561
 562   s = "123456";
 563   i = s.begin() + 1;
 564   ci = s.begin() + 1;
 565   s.replace(i, i + 3, ci + 1, cs.end());
 566   CPPUNIT_ASSERT( s == "1345656" );
 567
 568   s = "123456";
 569   i = s.begin();
 570   ci = s.begin() + 1;
 571   s.replace(i, i, ci, ci + 1);
 572   CPPUNIT_CHECK( s == "2123456" );
 573
 574   s = "123456";
 575   s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end());
 576   CPPUNIT_ASSERT( s == "1234123456" );
 577
 578   /*
 579    * This is the test for the template replace method.
 580    */
 581   s = "123456";
 582   string::iterator b = s.begin() + 4;
 583   string::iterator e = s.end();
 584   string::const_iterator rb = s.begin();
 585   string::const_iterator re = s.end();
 586   s.replace(b, e, rb, re);
 587   CPPUNIT_ASSERT( s == "1234123456" );
 588
 589   s = "123456";
 590   s.replace(s.begin() + 4, s.end(), s.begin(), s.end());
 591   CPPUNIT_ASSERT( s == "1234123456" );
 592
 593   string strorg("This is test string for string calls");
 594   string str = strorg;
 595   str.replace(5, 15, str.c_str(), 10);
 596   CPPUNIT_ASSERT( str == "This This is tefor string calls" );
 597
 598   str = strorg;
 599   str.replace(5, 5, str.c_str(), 10);
 600   CPPUNIT_ASSERT( str == "This This is test string for string calls" );
 601
 602 #if (defined (STLPORT) && defined(_STLP_MEMBER_TEMPLATES)) || ( !defined (STLPORT) && !defined(__GNUC__) )
 603   deque<char> cdeque;
 604   cdeque.push_back('I');
 605   str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end());
 606   CPPUNIT_ASSERT( str == "Is test string for string calls" );
 607 #endif
 608 }
 609
 610 void StringTest::resize()
 611 {
 612   string s;
 613
 614   s.resize(0);
 615
 616   CPPUNIT_ASSERT( *s.c_str() == 0 );
 617
 618   s = "1234567";
 619
 620   s.resize(0);
 621   CPPUNIT_ASSERT( *s.c_str() == 0 );
 622
 623   s = "1234567";
 624   s.resize(1);
 625   CPPUNIT_ASSERT( s.size() == 1 );
 626   CPPUNIT_ASSERT( *s.c_str() == '1' );
 627   CPPUNIT_ASSERT( *(s.c_str() + 1) == 0 );
 628
 629   s = "1234567";
 630   s.resize(10);
 631   CPPUNIT_ASSERT( s.size() == 10 );
 632   CPPUNIT_ASSERT( s[6] == '7' );
 633   CPPUNIT_ASSERT( s[7] == 0 );
 634   CPPUNIT_ASSERT( s[8] == 0 );
 635   CPPUNIT_ASSERT( s[9] == 0 );
 636 }
 637
 638 void StringTest::find()
 639 {
 640   string s("one two three one two three");
 641   CPPUNIT_ASSERT( s.find("one") == 0 );
 642   CPPUNIT_ASSERT( s.find('t') == 4 );
 643   CPPUNIT_ASSERT( s.find('t', 5) == 8 );
 644   //We are trying to get a const reference to the npos string static member to
 645   //force the compiler to allocate memory for this variable. It is used to reveal
 646   //a bug of STLport which was simply declaring npos without instanciating it.
 647 #if defined (STLPORT) && defined (_STLP_STATIC_CONST_INIT_BUG)
 648   string::size_type const& npos_local = string::npos;
 649 #else
 650 #  define npos_local string::npos
 651 #endif
 652   CPPUNIT_ASSERT( s.find("four") == npos_local );
 653   CPPUNIT_ASSERT( s.find("one", string::npos) == npos_local );
 654
 655   CPPUNIT_ASSERT( s.find_first_of("abcde") == 2 );
 656
 657   CPPUNIT_ASSERT( s.find_first_not_of("enotw ") == 9 );
 658
 659   string empty;
 660   CPPUNIT_ASSERT( s.substr(s.find(empty), empty.size()) == empty );
 661 }
 662
 663 void StringTest::bogus_edge_find()
 664 {
 665   /* ISO/IEC 14882 2003, 21.3.6.1 basic_string::find [lib.string::find]
 666    *
 667    * size_type find(const basic_string<charT,traits,Allocator>& str,
 668    *                size_type pos = 0) const;
 669    * Effects: Determines the lowest position xpos, if possible, such that
 670    * both of the following conditions obtain:
 671    *    pos <= xpos and xpos + str.size() <= size();
 672    *    at(xpos+I) == str.at(I) for all elements I of the string controlled by str.
 673    * Returns: xpos if the function can determine such a value for xpos. Otherwise,
 674    * returns npos.
 675    * Notes: Uses traits::eq().
 676    *
 677    * ===
 678    * So, from formal point of view
 679    *   string s; string::size_type p = s.find( "", 0, 0 );
 680    * should return 0 in p, i.e. position out-of-bound of string, so
 681    * code like following is bad:
 682    * string s;
 683    *
 684    * string::size_type p = s.find( "", 0, 0 );
 685    *
 686    * ...
 687    *
 688    * if ( p != string::npos ) { // normal
 689    *   char ch = s[p]; // Arghhhhhhhhhh
 690    * }
 691    *
 692    * People near Standard commete has opinion opposite to my. Even if it looks
 693    * like bogus behaviour for me, it should be fixed.
 694    */
 695
 696   {
 697     string s;
 698     string::size_type p = s.find( "", 0, 0 );
 699
 700     /* CPPUNIT_CHECK( p == string::npos ); */
 701     CPPUNIT_CHECK( p == 0 ); // bogus result, isn't it?
 702   }
 703   {
 704     string s( "123" );
 705     string::size_type p = s.find( "", 0, 0 );
 706
 707     CPPUNIT_CHECK( p == 0 );
 708   }
 709   {
 710     string s( "123" );
 711     string::size_type p = s.find( "", 1, 0 );
 712
 713     CPPUNIT_CHECK( p == 1 );
 714   }
 715   {
 716     string s( "" );
 717     string::size_type p = s.find( "", 1, 0 );
 718
 719     CPPUNIT_CHECK( p == string::npos );
 720   }
 721   {
 722     string s( "123" );
 723     string::size_type p = s.find( "", 3, 0 );
 724
 725     CPPUNIT_CHECK( p == 3 ); // bogus result, isn't it?
 726   }
 727   {
 728     string s;
 729     string::size_type p = s.rfind( "", 0, 0 );
 730
 731     /* CPPUNIT_CHECK( p == string::npos ); */
 732     CPPUNIT_CHECK( p == 0 ); // bogus result, isn't it?
 733   }
 734   {
 735     string s( "123" );
 736     string::size_type p = s.rfind( "", 0, 0 );
 737
 738     CPPUNIT_CHECK( p == 0 );
 739   }
 740   {
 741     string s( "123" );
 742     string::size_type p = s.rfind( "", 1, 0 );
 743
 744     CPPUNIT_CHECK( p == 1 );
 745   }
 746   {
 747     string s( "" );
 748     string::size_type p = s.rfind( "", 1, 0 );
 749
 750     CPPUNIT_CHECK( p == 0 ); // bogus result, isn't it?
 751   }
 752   {
 753     string s( "123" );
 754     string::size_type p = s.rfind( "", 3, 0 );
 755
 756     CPPUNIT_CHECK( p == 3 ); // bogus result, isn't it?
 757   }
 758 }
 759
 760 void StringTest::rfind()
 761 {
 762   // 21.3.6.2
 763   string s("one two three one two three");
 764
 765   CPPUNIT_ASSERT( s.rfind("two") == 18 );
 766   CPPUNIT_ASSERT( s.rfind("two", 0) == string::npos );
 767   CPPUNIT_ASSERT( s.rfind("two", 11) == 4 );
 768   CPPUNIT_ASSERT( s.rfind('w') == 19 );
 769
 770   string test( "aba" );
 771
 772   CPPUNIT_CHECK( test.rfind( "a", 2, 1 ) == 2 );
 773   CPPUNIT_CHECK( test.rfind( "a", 1, 1 ) == 0 );
 774   CPPUNIT_CHECK( test.rfind( "a", 0, 1 ) == 0 );
 775
 776   CPPUNIT_CHECK( test.rfind( 'a', 2 ) == 2 );
 777   CPPUNIT_CHECK( test.rfind( 'a', 1 ) == 0 );
 778   CPPUNIT_CHECK( test.rfind( 'a', 0 ) == 0 );
 779 }
 780
 781 void StringTest::find_last_of()
 782 {
 783   // 21.3.6.4
 784   string s("one two three one two three");
 785
 786   CPPUNIT_ASSERT( s.find_last_of("abcde") == 26 );
 787
 788   string test( "aba" );
 789
 790   CPPUNIT_CHECK( test.find_last_of( "a", 2, 1 ) == 2 );
 791   CPPUNIT_CHECK( test.find_last_of( "a", 1, 1 ) == 0 );
 792   CPPUNIT_CHECK( test.find_last_of( "a", 0, 1 ) == 0 );
 793
 794   CPPUNIT_CHECK( test.find_last_of( 'a', 2 ) == 2 );
 795   CPPUNIT_CHECK( test.find_last_of( 'a', 1 ) == 0 );
 796   CPPUNIT_CHECK( test.find_last_of( 'a', 0 ) == 0 );
 797 }
 798
 799 void StringTest::find_last_not_of()
 800 {
 801   // 21.3.6.6
 802   string s("one two three one two three");
 803
 804   CPPUNIT_ASSERT( s.find_last_not_of("ehortw ") == 15 );
 805
 806   string test( "aba" );
 807
 808   CPPUNIT_CHECK( test.find_last_not_of( "a", 2, 1 ) == 1 );
 809   CPPUNIT_CHECK( test.find_last_not_of( "b", 2, 1 ) == 2 );
 810   CPPUNIT_CHECK( test.find_last_not_of( "a", 1, 1 ) == 1 );
 811   CPPUNIT_CHECK( test.find_last_not_of( "b", 1, 1 ) == 0 );
 812   CPPUNIT_CHECK( test.find_last_not_of( "a", 0, 1 ) == string::npos );
 813   CPPUNIT_CHECK( test.find_last_not_of( "b", 0, 1 ) == 0 );
 814
 815   CPPUNIT_CHECK( test.find_last_not_of( 'a', 2 ) == 1 );
 816   CPPUNIT_CHECK( test.find_last_not_of( 'b', 2 ) == 2 );
 817   CPPUNIT_CHECK( test.find_last_not_of( 'a', 1 ) == 1 );
 818   CPPUNIT_CHECK( test.find_last_not_of( 'b', 1 ) == 0 );
 819   CPPUNIT_CHECK( test.find_last_not_of( 'a', 0 ) == string::npos );
 820   CPPUNIT_CHECK( test.find_last_not_of( 'b', 0 ) == 0 );
 821 }
 822
 823 void StringTest::copy()
 824 {
 825   string s("foo");
 826   char dest[4];
 827   dest[0] = dest[1] = dest[2] = dest[3] = 1;
 828   s.copy(dest, 4);
 829   int pos = 0;
 830   CPPUNIT_ASSERT( dest[pos++] == 'f' );
 831   CPPUNIT_ASSERT( dest[pos++] == 'o' );
 832   CPPUNIT_ASSERT( dest[pos++] == 'o' );
 833   CPPUNIT_ASSERT( dest[pos++] == 1 );
 834
 835   dest[0] = dest[1] = dest[2] = dest[3] = 1;
 836   s.copy(dest, 4, 2);
 837   pos = 0;
 838   CPPUNIT_ASSERT( dest[pos++] == 'o' );
 839   CPPUNIT_ASSERT( dest[pos++] == 1 );
 840
 841 #if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
 842   try {
 843     s.copy(dest, 4, 5);
 844     CPPUNIT_FAIL;
 845   }
 846   catch (out_of_range const&) {
 847   }
 848   catch ( ... ) {
 849     CPPUNIT_FAIL;
 850   }
 851 #endif
 852 }
 853
 854 void StringTest::assign()
 855 {
 856   string s;
 857   char const* cstr = "test string for assign";
 858
 859   s.assign(cstr, cstr + 22);
 860   CPPUNIT_ASSERT( s == "test string for assign" );
 861
 862   string s2("other test string");
 863   s.assign(s2);
 864   CPPUNIT_ASSERT( s == s2 );
 865
 866   static string str1;
 867   static string str2;
 868
 869   // short string optim:
 870   str1 = "123456";
 871   // longer than short string:
 872   str2 = "1234567890123456789012345678901234567890";
 873
 874   CPPUNIT_ASSERT(str1[5] == '6');
 875   CPPUNIT_ASSERT(str2[29] == '0');
 876 }
 877
 878 /* This test is to check if string properly supports the short string
 879  * optimization. It has been found out that eMbedded Visual C++ 3.0 and .NET
 880  * compilers for the ARM platform fail to pass structs and classes of certain
 881  * size per value. This seems to be a known compiler bug. For other processors
 882  * (e.g. x86) the error doesn't occur.
 883  * (The ARM compiler creates a temporary object from teststr on the stack, to
 884  * pass it to the helper function. It uses the copy constructor for this.
 885  * After this the temporary object is copied to another place on the stack.
 886  * The result is that the _M_finish pointer then points to the wrong buffer
 887  * end and the size of the short string is incorrectly calculated.)
 888  */
 889 void StringTest::short_string_optim_bug()
 890 {
 891    string teststr("shortest");
 892
 893    bool short_string_optim_bug_helper(string teststr);
 894
 895    CPPUNIT_ASSERT(true == short_string_optim_bug_helper(teststr));
 896 }
 897
 898 bool short_string_optim_bug_helper(string teststr)
 899 {
 900    size_t ss = teststr.size();
 901    return (ss == 8);
 902 }
 903
 904 void StringTest::compare()
 905 {
 906   string str1("abcdef");
 907   string str2;
 908
 909   str2 = "abcdef";
 910   CPPUNIT_ASSERT( str1.compare(str2) == 0 );
 911   str2 = "abcde";
 912   CPPUNIT_ASSERT( str1.compare(str2) > 0 );
 913   str2 = "abcdefg";
 914   CPPUNIT_ASSERT( str1.compare(str2) < 0 );
 915
 916   CPPUNIT_ASSERT( str1.compare("abcdef") == 0 );
 917   CPPUNIT_ASSERT( str1.compare("abcde") > 0 );
 918   CPPUNIT_ASSERT( str1.compare("abcdefg") < 0 );
 919
 920   str2 = "cde";
 921   CPPUNIT_ASSERT( str1.compare(2, 3, str2) == 0 );
 922   str2 = "cd";
 923   CPPUNIT_ASSERT( str1.compare(2, 3, str2) > 0 );
 924   str2 = "cdef";
 925   CPPUNIT_ASSERT( str1.compare(2, 3, str2) < 0 );
 926
 927   str2 = "abcdef";
 928   CPPUNIT_ASSERT( str1.compare(2, 3, str2, 2, 3) == 0 );
 929   CPPUNIT_ASSERT( str1.compare(2, 3, str2, 2, 2) > 0 );
 930   CPPUNIT_ASSERT( str1.compare(2, 3, str2, 2, 4) < 0 );
 931
 932   CPPUNIT_ASSERT( str1.compare(2, 3, "cdefgh", 3) == 0 );
 933   CPPUNIT_ASSERT( str1.compare(2, 3, "cdefgh", 2) > 0 );
 934   CPPUNIT_ASSERT( str1.compare(2, 3, "cdefgh", 4) < 0 );
 935 }
 936
 937 /*
 938 class mystring : public string {
 939 public:
 940   mystring() {}
 941   mystring(string const& s) : string(s) {}
 942
 943   mystring& operator = (string const& s) {
 944     string::operator = (s);
 945     return *this;
 946   };
 947 };
 948 */
 949
 950 void StringTest::template_expression()
 951 {
 952   string one("one"), two("two"), three("three");
 953   string space(1, ' ');
 954
 955   // check availability of [un]equality operators
 956   {
 957       // string-string
 958       one == two;
 959       one != two;
 960       // string-literal
 961       one == "two";
 962       one != "two";
 963       // literal-string
 964       "one" == two;
 965       "one" != two;
 966       // strsum-string
 967       (one + two) == three;
 968       (one + two) != three;
 969       // string-strsum
 970       one == (two + three);
 971       one != (two + three);
 972       // strsum-literal
 973       (one + two) == "three";
 974       (one + two) != "three";
 975       // literal-strsum
 976       "one" == (two + three);
 977       "one" != (two + three);
 978       // strsum-strsum
 979       (one + two) == (two + three);
 980       (one + two) != (two + three);
 981   }
 982
 983   {
 984     string result(one + ' ' + two + ' ' + three);
 985     CPPUNIT_CHECK( result == "one two three" );
 986   }
 987
 988   {
 989     string result(one + ' ' + two + ' ' + three, 4);
 990     CPPUNIT_CHECK( result == "two three" );
 991   }
 992
 993   {
 994     string result(one + ' ' + two + ' ' + three, 4, 3);
 995     CPPUNIT_CHECK( result == "two" );
 996   }
 997
 998   //2 members expressions:
 999   CPPUNIT_CHECK( (' ' + one) == " one" );
1000   CPPUNIT_CHECK( (one + ' ') == "one " );
1001   CPPUNIT_CHECK( (one + " two") == "one two" );
1002   CPPUNIT_CHECK( ("one " + two) == "one two" );
1003   CPPUNIT_CHECK( (one + space) == "one " );
1004
1005   //3 members expressions:
1006   CPPUNIT_CHECK( ((one + space) + "two") == "one two" );
1007   CPPUNIT_CHECK( ("one" + (space + two)) == "one two" );
1008   CPPUNIT_CHECK( ((one + space) + two) == "one two" );
1009   CPPUNIT_CHECK( (one + (space + two)) == "one two" );
1010   CPPUNIT_CHECK( ((one + space) + 't') == "one t" );
1011   CPPUNIT_CHECK( ('o' + (space + two)) == "o two" );
1012
1013   //4 members expressions:
1014   CPPUNIT_CHECK( ((one + space) + (two + space)) == "one two " );
1015
1016   //special operators
1017   {
1018     string result;
1019     result = one + space + two;
1020     CPPUNIT_CHECK( result == "one two" );
1021
1022     result += space + three;
1023     CPPUNIT_CHECK( result == "one two three" );
1024   }
1025
1026   //special append method
1027   {
1028     string result;
1029     //Use reserve to avoid reallocation and really test auto-referencing problems:
1030     result.reserve(64);
1031
1032     result.append(one + space + two);
1033     CPPUNIT_CHECK( result == "one two" );
1034
1035     result.append(space + result + space + three);
1036     CPPUNIT_CHECK( result == "one two one two three" );
1037
1038     result = "one two";
1039     result.append(space + three, 1, 2);
1040     CPPUNIT_ASSERT( result == "one twoth" );
1041
1042     result.append(space + result);
1043     CPPUNIT_CHECK( result == "one twoth one twoth" );
1044   }
1045
1046   //special assign method
1047   {
1048     string result;
1049     //Use reserve to avoid reallocation and really test auto-referencing problems:
1050     result.reserve(64);
1051
1052     result.assign(one + space + two + space + three);
1053     CPPUNIT_CHECK( result == "one two three" );
1054
1055     result.assign(one + space + two + space + three, 3, 5);
1056     CPPUNIT_CHECK( result == " two " );
1057
1058     result.assign(one + result + three);
1059     CPPUNIT_CHECK( result == "one two three" );
1060   }
1061
1062   {
1063     CPPUNIT_CHECK( !(one + ' ' + two).empty() );
1064
1065     char result = (one + ' ' + two)[3];
1066     CPPUNIT_CHECK( result == ' ' );
1067
1068     result = (one + ' ' + two).at(3);
1069     CPPUNIT_CHECK( result == ' ' );
1070
1071 #if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
1072     try {
1073       result = (one + ' ' + two).at(10);
1074       CPPUNIT_FAIL;
1075     }
1076     catch (out_of_range const&) {
1077       CPPUNIT_ASSERT( result == ' ' );
1078     }
1079     catch (...) {
1080       CPPUNIT_FAIL;
1081     }
1082 #endif
1083   }
1084
1085   /*
1086   mystring a("ing");
1087   //gcc failed to compile following expression when template expressions are activated.
1088   //MSVC sees no problem. gcc limitation or MSVC is too cool ??
1089   mystring b = "str" + a;
1090   */
1091 }
1092
1093 #if !defined (TE_TMP_TEST_IGNORED)
1094 class superstring
1095 {
1096   public:
1097     superstring() :
1098       s("super")
1099     {}
1100
1101     superstring( const string& str ) :
1102       s( str )
1103     {}
1104
1105   superstring operator / (const string& str )
1106     { return superstring( s + "/" + str ); }
1107
1108   superstring operator / (const char* str )
1109     { return superstring( s + "/" + str ); }
1110
1111   private:
1112     string s;
1113 };
1114 #endif
1115
1116 void StringTest::te_tmp()
1117 {
1118 #if !defined (TE_TMP_TEST_IGNORED)
1119   superstring s;
1120   string more( "more" );
1121   string less( "less" );
1122
1123   superstring r = s / (more + less);
1124 #endif
1125 }
1126
1127 class mypath
1128 {
1129   public:
1130     mypath( const string& s ) :
1131         p( s )
1132       { }
1133
1134     const mypath& operator / ( const string& );
1135     const string& str() const
1136       { return p; }
1137
1138   private:
1139     string p;
1140 };
1141
1142 const mypath& mypath::operator /( const string& s )
1143 {
1144   p += '/';
1145   p += s;
1146   return *this;
1147 }
1148
1149 void StringTest::oper_tmp()
1150 {
1151   string s1( "path1" );
1152   string s2( ".ext" );
1153
1154   string& rs1 = s1;
1155   string& rs2 = s2;
1156
1157   CPPUNIT_CHECK( (mypath( string( "/root" ) ) / (rs1 + rs2)).str() == "/root/path1.ext" );
1158 }
1159
1160 void StringTest::template_wexpression()
1161 {
1162 #if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
1163 #  if !defined (__CYGWIN__) || defined (STLPORT)
1164   wstring one(L"one"), two(L"two"), three(L"three");
1165   wstring space(L" ");
1166
1167   {
1168     wstring result(one + L' ' + two + L' ' + three);
1169     CPPUNIT_CHECK( result == L"one two three" );
1170   }
1171
1172   {
1173     wstring result(one + L' ' + two + L' ' + three, 4);
1174     CPPUNIT_CHECK( result == L"two three" );
1175   }
1176
1177   {
1178     wstring result(one + L' ' + two + L' ' + three, 4, 3);
1179     CPPUNIT_CHECK( result == L"two" );
1180   }
1181
1182   //2 members expressions:
1183   CPPUNIT_CHECK( (L' ' + one) == L" one" );
1184   CPPUNIT_CHECK( (one + L' ') == L"one " );
1185   CPPUNIT_CHECK( (one + L" two") == L"one two" );
1186   CPPUNIT_CHECK( (L"one " + two) == L"one two" );
1187   CPPUNIT_CHECK( (one + space) == L"one " );
1188
1189   //3 members expressions:
1190   CPPUNIT_CHECK( ((one + space) + L"two") == L"one two" );
1191   CPPUNIT_CHECK( (L"one" + (space + two)) == L"one two" );
1192   CPPUNIT_CHECK( ((one + space) + two) == L"one two" );
1193   CPPUNIT_CHECK( (one + (space + two)) == L"one two" );
1194   CPPUNIT_CHECK( ((one + space) + L't') == L"one t" );
1195   CPPUNIT_CHECK( (L'o' + (space + two)) == L"o two" );
1196
1197   //4 members expressions:
1198   CPPUNIT_CHECK( ((one + space) + (two + space)) == L"one two " );
1199
1200   //special operators
1201   {
1202     wstring result;
1203     result = one + space + two;
1204     CPPUNIT_CHECK( result == L"one two" );
1205
1206     result += space + three;
1207     CPPUNIT_CHECK( result == L"one two three" );
1208   }
1209
1210   //special append method
1211   {
1212     wstring result;
1213     //Use reserve to avoid reallocation and really test auto-referencing problems:
1214     result.reserve(64);
1215
1216     result.append(one + space + two);
1217     CPPUNIT_CHECK( result == L"one two" );
1218
1219     result.append(space + result + space + three);
1220     CPPUNIT_CHECK( result == L"one two one two three" );
1221
1222     result = L"one two";
1223     result.append(space + three, 1, 2);
1224     CPPUNIT_ASSERT( result == L"one twoth" );
1225
1226     result.append(space + result);
1227     CPPUNIT_CHECK( result == L"one twoth one twoth" );
1228   }
1229
1230   //special assign method
1231   {
1232     wstring result;
1233     //Use reserve to avoid reallocation and really test auto-referencing problems:
1234     result.reserve(64);
1235
1236     result.assign(one + space + two + space + three);
1237     CPPUNIT_CHECK( result == L"one two three" );
1238
1239     result.assign(one + space + two + space + three, 3, 5);
1240     CPPUNIT_CHECK( result == L" two " );
1241
1242     result.assign(one + result + three);
1243     CPPUNIT_CHECK( result == L"one two three" );
1244   }
1245
1246   {
1247     CPPUNIT_CHECK( !(one + L' ' + two).empty() );
1248
1249     wchar_t result = (one + L' ' + two)[3];
1250     CPPUNIT_CHECK( result == L' ' );
1251
1252     result = (one + L' ' + two).at(3);
1253     CPPUNIT_CHECK( result == L' ' );
1254
1255 #    if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
1256     try {
1257       result = (one + L' ' + two).at(10);
1258       CPPUNIT_FAIL;
1259     }
1260     catch (out_of_range const&) {
1261       CPPUNIT_ASSERT( result == L' ' );
1262     }
1263     catch (...) {
1264       CPPUNIT_FAIL;
1265     }
1266 #    endif
1267   }
1268 #  endif
1269 #endif
1270 }
1271
1272 void StringTest::io()
1273 {
1274 #if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
1275   string str("STLport");
1276   {
1277     ostringstream ostr;
1278     ostr << str;
1279     CPPUNIT_ASSERT( ostr.good() );
1280     CPPUNIT_ASSERT( ostr.str() == str );
1281   }
1282   {
1283     istringstream istr(str);
1284     string istr_content;
1285     istr >> istr_content;
1286     CPPUNIT_ASSERT( !istr.fail() && istr.eof() );
1287     CPPUNIT_ASSERT( istr_content == str );
1288   }
1289   {
1290     istringstream istr(str);
1291     istr.width(3);
1292     string istr_content;
1293     istr >> istr_content;
1294     CPPUNIT_ASSERT( !istr.fail() && !istr.eof() );
1295     CPPUNIT_ASSERT( istr_content == "STL" );
1296   }
1297 #endif
1298 }
1299
1300 void StringTest::allocator_with_state()
1301 {
1302 #if !(defined (STLPORT) && defined (_STLP_NO_CUSTOM_IO))
1303
1304   char buf1[1024];
1305   StackAllocator<char> stack1(buf1, buf1 + sizeof(buf1));
1306
1307   char buf2[1024];
1308   StackAllocator<char> stack2(buf2, buf2 + sizeof(buf2));
1309
1310   typedef basic_string<char, char_traits<char>, StackAllocator<char> > StackString;
1311   {
1312     StackString str1("string stack1", stack1);
1313     StackString str1Cpy(str1);
1314
1315     StackString str2("string stack2", stack2);
1316     StackString str2Cpy(str2);
1317
1318     str1.swap(str2);
1319
1320     CPPUNIT_ASSERT( str1.get_allocator().swaped() );
1321     CPPUNIT_ASSERT( str2.get_allocator().swaped() );
1322
1323     CPPUNIT_ASSERT( str1 == str2Cpy );
1324     CPPUNIT_ASSERT( str2 == str1Cpy );
1325     CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
1326     CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
1327   }
1328   CPPUNIT_ASSERT( stack1.ok() );
1329   CPPUNIT_ASSERT( stack2.ok() );
1330   stack1.reset(); stack2.reset();
1331
1332   {
1333     StackString str1("longer string from stack1 allocator instance for dynamic allocation", stack1);
1334     StackString str1Cpy(str1);
1335
1336     StackString str2("longer string from stack2 allocator instance for dynamic allocation", stack2);
1337     StackString str2Cpy(str2);
1338
1339     str1.swap(str2);
1340
1341     CPPUNIT_ASSERT( str1.get_allocator().swaped() );
1342     CPPUNIT_ASSERT( str2.get_allocator().swaped() );
1343
1344     CPPUNIT_ASSERT( str1 == str2Cpy );
1345     CPPUNIT_ASSERT( str2 == str1Cpy );
1346     CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
1347     CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
1348   }
1349   CPPUNIT_ASSERT( stack1.ok() );
1350   CPPUNIT_ASSERT( stack2.ok() );
1351   stack1.reset(); stack2.reset();
1352
1353
1354   {
1355     StackString str1("string stack1", stack1);
1356     StackString str1Cpy(str1);
1357
1358     StackString str2("longer string from stack2 allocator instance for dynamic allocation", stack2);
1359     StackString str2Cpy(str2);
1360
1361     str1.swap(str2);
1362
1363     CPPUNIT_ASSERT( str1.get_allocator().swaped() );
1364     CPPUNIT_ASSERT( str2.get_allocator().swaped() );
1365
1366     CPPUNIT_ASSERT( str1 == str2Cpy );
1367     CPPUNIT_ASSERT( str2 == str1Cpy );
1368     CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
1369     CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
1370   }
1371   CPPUNIT_ASSERT( stack1.ok() );
1372   CPPUNIT_ASSERT( stack2.ok() );
1373   stack1.reset(); stack2.reset();
1374
1375
1376   {
1377     StackString str1("longer string from stack1 allocator instance for dynamic allocation", stack1);
1378     StackString str1Cpy(str1);
1379
1380     StackString str2("string stack2", stack2);
1381     StackString str2Cpy(str2);
1382
1383     str1.swap(str2);
1384
1385     CPPUNIT_ASSERT( str1.get_allocator().swaped() );
1386     CPPUNIT_ASSERT( str2.get_allocator().swaped() );
1387
1388     CPPUNIT_ASSERT( str1 == str2Cpy );
1389     CPPUNIT_ASSERT( str2 == str1Cpy );
1390     CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
1391     CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
1392   }
1393   CPPUNIT_ASSERT( stack1.ok() );
1394   CPPUNIT_ASSERT( stack2.ok() );
1395   stack1.reset(); stack2.reset();
1396 #endif
1397 }
1398
1399 void StringTest::capacity()
1400 {
1401   string s;
1402
1403   CPPUNIT_CHECK( s.capacity() > 0 );
1404   CPPUNIT_CHECK( s.capacity() < s.max_size() );
1405   CPPUNIT_CHECK( s.capacity() >= s.size() );
1406
1407 #ifndef _STLP_SHORT_STRING_SZ
1408 #  define _STLP_SHORT_STRING_SZ 16 // see stlport/stl/_string_base.h
1409 #endif
1410
1411   for ( int i = 0; i < _STLP_SHORT_STRING_SZ + 2; ++i ) {
1412     s += ' ';
1413     CPPUNIT_CHECK( s.capacity() > 0 );
1414     CPPUNIT_CHECK( s.capacity() < s.max_size() );
1415     CPPUNIT_CHECK( s.capacity() >= s.size() );
1416   }
1417 }
1418
1419 void StringTest::concat24()
1420 {
1421   string s = string( "123456789012345678901234" ) + string( "123456789012345678901234" );
1422
1423   CPPUNIT_CHECK( s.length() == 48 );
1424   CPPUNIT_CHECK( s[23] == '4' );
1425   CPPUNIT_CHECK( s[24] == '1' );
1426   CPPUNIT_CHECK( s[47] == '4' );
1427 }