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)
41using namespace std;
42#endif
43
44//
45// TestCase class
46//
47class 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
109protected:
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
164CPPUNIT_TEST_SUITE_REGISTRATION(StringTest);
165
166//
167// tests implementation
168//
169void 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
185void StringTest::trivial_char_compare()
186{
187  string s( "message" );
188
189  CPPUNIT_CHECK( s == "message" );
190  CPPUNIT_CHECK( "message" == s );
191}
192
193void 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
210void 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
254void 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
325void 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
375void 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
410void 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
432void 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
454void 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
530void 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
610void 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
638void 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
663void 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
760void 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
781void 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
799void 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
823void 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
854void 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 */
889void 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
898bool short_string_optim_bug_helper(string teststr)
899{
900   size_t ss = teststr.size();
901   return (ss == 8);
902}
903
904void 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/*
938class mystring : public string {
939public:
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
950void 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)
1094class 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
1116void 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
1127class 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
1142const mypath& mypath::operator /( const string& s )
1143{
1144  p += '/';
1145  p += s;
1146  return *this;
1147}
1148
1149void 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
1160void 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
1272void 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
1300void 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
1399void 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
1419void 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}
1428