ReactOS  0.4.13-dev-79-gcd489d8
string_test.cpp
Go to the documentation of this file.
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 {
50  CPPUNIT_TEST(constructor);
51  CPPUNIT_TEST(trivial_char_compare);
53  CPPUNIT_TEST(assign);
54  CPPUNIT_TEST(erase);
56  CPPUNIT_TEST(c_str);
57  CPPUNIT_TEST(null_char);
60  CPPUNIT_TEST(resize);
61  CPPUNIT_TEST(short_string);
63  CPPUNIT_TEST(bogus_edge_find);
64  CPPUNIT_TEST(rfind);
65  CPPUNIT_TEST(find_last_of);
66  CPPUNIT_TEST(find_last_not_of);
68 #if !defined (USE_PTHREAD_API) && !defined (USE_WINDOWS_API)
70 #endif
71  CPPUNIT_TEST(mt);
73  CPPUNIT_TEST(short_string_optim_bug);
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
81 #endif
82  CPPUNIT_TEST(te_tmp);
83 #if defined (TE_TMP_TEST_IGNORED)
85 #endif
86  CPPUNIT_TEST(oper_tmp);
87 #if defined (STLPORT) && defined (_STLP_NO_WCHAR_T)
89 #endif
90 #if defined (__CYGWIN__) && !defined (STLPORT)
92 #endif
93  CPPUNIT_TEST(template_wexpression);
95 #if defined (STLPORT) && defined (_STLP_USE_NO_IOSTREAMS)
97 #endif
100 #if defined (STLPORT) && defined (_STLP_NO_CUSTOM_IO)
102 #endif
103  CPPUNIT_TEST(allocator_with_state);
105  CPPUNIT_TEST(capacity);
106  CPPUNIT_TEST(concat24);
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 
165 
166 //
167 // tests implementation
168 //
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 
186 {
187  string s( "message" );
188 
189  CPPUNIT_CHECK( s == "message" );
190  CPPUNIT_CHECK( "message" == s );
191 }
192 
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 
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 
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 ) {
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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  */
890 {
891  string teststr("shortest");
892 
893  bool short_string_optim_bug_helper(string teststr);
894 
896 }
897 
898 bool short_string_optim_bug_helper(string teststr)
899 {
900  size_t ss = teststr.size();
901  return (ss == 8);
902 }
903 
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 
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)
1095 {
1096  public:
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 
1109  { return superstring( s + "/" + str ); }
1110 
1111  private:
1112  string s;
1113 };
1114 #endif
1115 
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 
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 
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 
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 
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 
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 
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 
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 }
GLenum func
Definition: glext.h:6028
Definition: bug.cpp:7
void assign()
#define _STLP_SHORT_STRING_SZ
void erase()
struct S2 s2
#define TRUE
Definition: types.h:120
void swap(StackAllocator< _Tp > &__a, StackAllocator< _Tp > &__b)
string p
basic_ostringstream< char, char_traits< char >, allocator< char > > ostringstream
Definition: _iosfwd.h:127
void push_back(const value_type &__t=_STLP_DEFAULT_CONSTRUCTED(_Tp))
Definition: _deque.h:668
void find_last_not_of()
void allocator_with_state()
void bogus_edge_find()
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
static const WCHAR empty[]
Definition: main.c:49
iterator end()
Definition: _deque.h:433
bool ok() const
static const size_t npos
Definition: _string_npos.h:26
GLdouble GLdouble t
Definition: gl.h:2047
#define CPPUNIT_TEST_SUITE(X)
Definition: cppunit_mini.h:142
void reserve()
void capacity()
#define test
Definition: rosglue.h:37
#define CPPUNIT_TEST(X)
Definition: cppunit_mini.h:182
static int insert
Definition: xmllint.c:144
bool fail() const
Definition: _ios_base.h:174
Definition: features.h:417
DWORD WINAPI WaitForMultipleObjects(IN DWORD nCount, IN CONST HANDLE *lpHandles, IN BOOL bWaitAll, IN DWORD dwMilliseconds)
Definition: synch.c:151
const mypath & operator/(const string &)
#define npos_local
const string & str() const
static double one
Definition: j0_y0.c:80
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
uint32_t cs
Definition: isohybrid.c:75
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
superstring(const string &str)
#define a
Definition: ke_i.h:78
#define e
Definition: ke_i.h:82
static double two
Definition: jn_yn.c:52
void oper_tmp()
const WCHAR * str
iterator begin()
Definition: _deque.h:432
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:112
smooth NULL
Definition: ftsmooth.c:416
#define CPPUNIT_TEST_SUITE_END()
Definition: cppunit_mini.h:191
mypath(const string &s)
void rfind()
#define b
Definition: ke_i.h:79
INT replace(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], DWORD dwFlags, BOOL *doMore)
Definition: replace.c:47
GLfloat f
Definition: glext.h:7540
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define CPPUNIT_CHECK(X)
Definition: cppunit_mini.h:195
void find_last_of()
void short_string_optim_bug()
struct S1 s1
void template_wexpression()
int xx
Definition: npserver.c:29
unsigned long DWORD
Definition: ntddk_ex.h:95
#define WAIT_FAILED
Definition: winbase.h:394
#define __stdcall
Definition: typedefs.h:25
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
Definition: _deque.h:400
CPPUNIT_TEST_SUITE_REGISTRATION(StringTest)
bool short_string_optim_bug_helper(string teststr)
bool eof() const
Definition: _ios_base.h:173
static const WCHAR L[]
Definition: oid.c:1250
void replace()
#define CPPUNIT_FAIL
Definition: cppunit_mini.h:206
GLdouble s
Definition: gl.h:2039
#define CPPUNIT_STOP_IGNORE
Definition: cppunit_mini.h:188
char string[160]
Definition: util.h:11
#define CPPUNIT_ASSERT(X)
Definition: cppunit_mini.h:200
streamsize width() const
Definition: _ios_base.h:134
static BOOL reserve(struct dynamic_array *array, int count, int itemsize)
Definition: mesh.c:5392
const GLdouble * v
Definition: gl.h:2040
void resize()
#define f
Definition: ke_i.h:83
void concat24()
void null_char()
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
void constructor()
void template_expression()
static TAGID TAGID find
Definition: db.cpp:153
#define compare
void short_string()
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
void insert()
static char * dest
Definition: rtl.c:135
#define CPPUNIT_IGNORE
Definition: cppunit_mini.h:185
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
complex< _Tp > _STLP_CALL operator/(const _Tp &__x, const complex< _Tp > &__z)
Definition: _complex.h:652
GLfloat GLfloat p
Definition: glext.h:8902
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK io
Definition: file.c:100
void c_str()
static string func(const string &par)
#define ss
Definition: i386-dis.c:432
#define INFINITE
Definition: serial.h:102
static struct msdos_boot_sector bs
Definition: mkdosfs.c:539
void compare()
GLuint64EXT * result
Definition: glext.h:11304
void trivial_char_compare()