1 /* -*- c++ -*- */
2 /*
3 * Copyright (C) 2009 The Android Open Source Project
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * * Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
19 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
20 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
22 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
23 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 #include "../include/string"
31 #ifndef ANDROID_ASTL_STRING__
32 #error "Wrong header included!!"
33 #endif
34 #include <climits>
35 #include <cstring>
36 #include <algorithm>
37 #include <list>
38 #include "common.h"
39
40
41 namespace android {
42 using std::string;
43
testConstructorCString()44 bool testConstructorCString()
45 {
46 string empty_str1;
47 EXPECT_TRUE(empty_str1.size() == 0);
48 EXPECT_TRUE(empty_str1.capacity() == 0);
49
50 string empty_str2("");
51 EXPECT_TRUE(empty_str2.size() == 0);
52
53 const char empty_as_array[] = "";
54 string empty_str3(empty_as_array);
55 EXPECT_TRUE(empty_str3.size() == 0);
56
57 const char literal[] = "scott mills cracks me up";
58 string str1(literal);
59 EXPECT_TRUE(strcmp(literal, str1.c_str()) == 0);
60
61 string str2(literal, 11);
62 EXPECT_TRUE(strcmp("scott mills", str2.c_str()) == 0);
63
64 string str3(literal, sizeof(literal));
65 EXPECT_TRUE(strcmp(literal, str3.c_str()) == 0);
66
67 // Pass the end of the string => still ok, there is \0
68 string str4(literal, sizeof(literal) + 1);
69 EXPECT_TRUE(str4.size() == sizeof(literal) + 1);
70
71 string str5(literal, literal + 11);
72 EXPECT_TRUE(strcmp("scott mills", str5.c_str()) == 0);
73
74 const char text[] = {'l','a','d','y',' ','g','a','g','a'};
75
76 string str6(text, ARRAYSIZE(text));
77 EXPECT_TRUE(str6 == "lady gaga");
78
79 string str7(NULL);
80 EXPECT_TRUE(empty_str1.size() == 0);
81 EXPECT_TRUE(empty_str1.empty());
82 return true;
83 }
84
testConstructorString()85 bool testConstructorString()
86 {
87 string empty_str1;
88 string empty_str2;
89 EXPECT_TRUE(empty_str1.c_str() == empty_str2.c_str());
90
91 string empty_str3(empty_str2);
92 EXPECT_TRUE(empty_str3.size() == 0);
93
94 const char string_with_nulls[] = "contains 2 \0 bytes \0.";
95 string str1 (string_with_nulls, 21);
96 EXPECT_TRUE(str1.size() == 21);
97
98 string str2 (str1);
99 EXPECT_TRUE(str1.size() == 21);
100
101 const string str3("scott mills cracks me up");
102 string str4(str3, 12);
103 EXPECT_TRUE(strcmp("cracks me up", str4.c_str()) == 0);
104
105 string str5(str3, 12, 6);
106 EXPECT_TRUE(strcmp("cracks", str5.c_str()) == 0);
107
108 string str6(str3, 23);
109 EXPECT_TRUE(strcmp("p", str6.c_str()) == 0);
110
111 string str7(str3, 24);
112 EXPECT_TRUE(strcmp("", str7.c_str()) == 0);
113
114 string str8(str3, 23, 1);
115 EXPECT_TRUE(strcmp("p", str8.c_str()) == 0);
116
117 string str9(str3, 24, 1);
118 EXPECT_TRUE(strcmp("", str9.c_str()) == 0);
119
120 return true;
121 }
122
testConstructorPointers()123 bool testConstructorPointers()
124 {
125 const string empty;
126 char data[] = "a 16 char string";
127
128 string str01(data, data + 0);
129 EXPECT_TRUE(str01.c_str() == empty.c_str());
130
131 string str02(data, data + 1);
132 EXPECT_TRUE(str02 == "a");
133
134 string str03(data + 2, data + 16);
135 EXPECT_TRUE(str03 == "16 char string");
136
137 string str04(data + 15, data + 16);
138 EXPECT_TRUE(str04 == "g");
139
140 string str05(data + 16, data + 16);
141 EXPECT_TRUE(str05 == "");
142
143 return true;
144 }
145
testConstructorRepeatChar()146 bool testConstructorRepeatChar()
147 {
148 string str01(0, 'c');
149
150 EXPECT_TRUE(str01.empty());
151 EXPECT_TRUE(str01.size() == 0);
152 EXPECT_TRUE(str01.capacity() == 0);
153
154 string str02(10, 'c');
155
156 EXPECT_TRUE(!str02.empty());
157 EXPECT_TRUE(str02.size() == 10);
158 EXPECT_TRUE(str02.capacity() == 10);
159
160 for (size_t i = 0; i < 100; ++i)
161 {
162 string str03(i, 'x');
163
164 EXPECT_TRUE(str03[i] == '\0');
165 EXPECT_TRUE(str03.length() == i);
166
167 str03.reserve(i + 20);
168 EXPECT_TRUE(str03.capacity() == i + 20);
169 EXPECT_TRUE(str03.length() == i);
170 EXPECT_TRUE(str03[i] == '\0');
171 }
172
173 return true;
174 }
175
testConstructorInvalidValues()176 bool testConstructorInvalidValues()
177 {
178 const string empty;
179 const string str01("a 16 char string");
180
181 EXPECT_TRUE(str01.size() == 16);
182
183 string str02(str01, 17, 1); // invalid index
184 EXPECT_TRUE(str02.c_str() == empty.c_str());
185
186 string str03(str01, 17, 0); // invalid index
187 EXPECT_TRUE(str03.c_str() == empty.c_str());
188
189 string str04(str01, -1, 0); // invalid index
190 EXPECT_TRUE(str04.c_str() == empty.c_str());
191
192 string str05(str01, 0, 17); // invalid length -> clamped
193 EXPECT_TRUE(str05 == str01);
194
195 string str06(str01, 17); // invalid index
196 EXPECT_TRUE(str06.c_str() == empty.c_str());
197
198 char end[] = "a string";
199 char *begin = end + 1; // begin after end.
200
201 string str07(begin, end);
202 EXPECT_TRUE(str07.c_str() == empty.c_str());
203
204 return true;
205 }
206
testSize()207 bool testSize()
208 {
209 string str01;
210 EXPECT_TRUE(str01.size() == 0);
211 EXPECT_TRUE(str01.length() == 0);
212
213 str01 += "a string.";
214
215 EXPECT_TRUE(str01.size() == 9);
216 EXPECT_TRUE(str01.length() == 9);
217
218 return true;
219 }
220
testCString()221 bool testCString()
222 {
223 string str01;
224 string str02;
225
226 // Should point to the same empty string.
227 EXPECT_TRUE(str01.c_str() == str02.c_str());
228 // c_str() == data()
229 EXPECT_TRUE(str01.c_str() == str01.data());
230 EXPECT_TRUE(str01.empty());
231
232 const char text[] = "a string";
233 str01 += text;
234 EXPECT_TRUE(strcmp(str01.c_str(), text) == 0);
235 EXPECT_TRUE(strcmp(str01.data(), text) == 0);
236 EXPECT_TRUE(!str01.empty());
237
238 // after a clear, points back to the original empty string.
239 str01.clear();
240 EXPECT_TRUE(str01.c_str() == str02.c_str());
241 EXPECT_TRUE(str01.empty());
242
243 return true;
244 }
245
testReserve()246 bool testReserve()
247 {
248 string str01;
249 size_t capacity = str01.capacity();
250
251 EXPECT_TRUE(0 == capacity);
252
253 str01.reserve(5);
254 EXPECT_TRUE(5 == str01.capacity());
255 str01.reserve(0);
256 EXPECT_TRUE(0 == str01.capacity());
257
258 string str02("7 chars");
259 EXPECT_TRUE(7 == str02.capacity());
260 EXPECT_TRUE(7 == str02.size());
261
262 str02.reserve(10);
263 EXPECT_TRUE(str02 == "7 chars");
264 EXPECT_TRUE(10 == str02.capacity());
265 EXPECT_TRUE(7 == str02.size());
266
267 str02.reserve(6); // no effect
268 EXPECT_TRUE(str02 == "7 chars");
269 EXPECT_TRUE(10 == str02.capacity());
270 EXPECT_TRUE(7 == str02.size());
271
272 string str03;
273 const string str04;
274
275 // Both point to kEmptyString.
276 EXPECT_TRUE(str03.c_str() == str04.c_str());
277
278 str03.reserve();
279 EXPECT_TRUE(0 == str03.capacity());
280 EXPECT_TRUE(str03.c_str() == str04.c_str());
281
282 str03.reserve(10);
283 EXPECT_TRUE(10 == str03.capacity());
284 // Not pointing at the empty string anymore.
285 EXPECT_TRUE(str03.c_str() != str04.c_str());
286
287 str03.reserve();
288 EXPECT_TRUE(0 == str03.capacity());
289 // c_str() points back to the empty string.
290 EXPECT_TRUE(str03.c_str() == str04.c_str());
291
292 str03.reserve(10);
293 str03.append("7 chars");
294 EXPECT_TRUE(str03 == "7 chars");
295 str03.reserve(); // shrink to fit.
296 EXPECT_TRUE(7 == str03.capacity());
297
298 string str05 = "twelve chars";
299 string str06 = str05;
300 str05.reserve(1);
301 EXPECT_TRUE(str05.capacity() == 12);
302
303
304 for (size_t i = 1; i <= 100; i *= 2)
305 {
306 string str(i, 'x');
307 str.reserve(3 * i);
308 EXPECT_TRUE(str.capacity() == 3 * i);
309
310 str.reserve(2 * i);
311 EXPECT_TRUE(str.capacity() == 2 * i);
312
313 str.reserve();
314 EXPECT_TRUE(str.capacity() == i);
315 }
316
317 // Check overflow.
318 string str07;
319
320 str07.reserve(10);
321 EXPECT_TRUE(str07.capacity() == 10);
322
323 str07.reserve(kMaxSizeT);
324
325 EXPECT_TRUE(str07.capacity() == 10);
326
327 return true;
328 }
329
testAppend()330 bool testAppend()
331 {
332 string str1;
333 const char *text = "You spin my head right round.";
334
335 str1.append(text);
336 EXPECT_TRUE(str1 == text);
337
338 str1.append(" Flo Rida.");
339 EXPECT_TRUE(str1 == "You spin my head right round. Flo Rida.");
340
341 string str2;
342 str2.append(str1);
343 EXPECT_TRUE(str2 == "You spin my head right round. Flo Rida.");
344
345 string str3("You spin ");
346 str3.append("my head right round.");
347 EXPECT_TRUE(str3 == "You spin my head right round.");
348
349 string str4("You spin ");
350 string str5("my head right round.");
351 str4.append(str5);
352 EXPECT_TRUE(str4 == "You spin my head right round.");
353
354 string str6("");
355 string str7("");
356 str6.append(str7);
357 EXPECT_TRUE(str6 == "");
358 EXPECT_TRUE(str6.empty());
359
360 string str8;
361 str8.append("a");
362 EXPECT_TRUE(str8 == "a");
363
364 const char more_text[] = {'l','a','d','y',' ','g','a','g','a'};
365
366 string str9;
367 str9.append(more_text, ARRAYSIZE(more_text));
368 EXPECT_TRUE(str9 == string(more_text, ARRAYSIZE(more_text)));
369
370 string str10;
371 str10.append("", 0);
372 EXPECT_TRUE(str10.size() == 0 );
373 str10.append(text, strlen(text));
374 EXPECT_TRUE(str10 == "You spin my head right round.");
375
376 string str11;
377 str11.append("You spin my head right round.", 5, 11);
378
379 EXPECT_TRUE(str11 == "pin my head");
380
381 // Append overflow
382 string str12("original");
383 char dummy[] = "unused";
384 // We lie about the size but that is ok. Since the lenght of the new string
385 // is going to be kMaxSizeT, the call will have not effect (there is no
386 // space for the trailing '\0').
387 str12.append(dummy, kMaxSizeT);
388 EXPECT_TRUE(str12 == "original");
389
390 // Append iterator.
391 {
392 string str1("once upon ");
393 const string str2("a time");
394
395 str1.append(str2.begin(), str2.end());
396 EXPECT_TRUE(str1.size() == 16);
397 EXPECT_TRUE(str1 == "once upon a time");
398 }
399 {
400 string str1("once upon ");
401 string str2("a time");
402
403 str1.append(str2.begin(), str2.begin());
404 EXPECT_TRUE(str1.size() == 10);
405 EXPECT_TRUE(str1 == "once upon ");
406 }
407 {
408 string str1;
409 string str2("hello");
410
411 str1.append(str2.begin(), str2.end());
412 EXPECT_TRUE(str1.size() == 5);
413 EXPECT_TRUE(str1 == "hello");
414 }
415 {
416 string str1("hello ");
417 std::list<char> list1;
418 list1.push_back('w');
419 list1.push_back('o');
420 list1.push_back('r');
421 list1.push_back('l');
422 list1.push_back('d');
423 str1.append(list1.begin(), list1.end());
424 EXPECT_TRUE(str1 == "hello world");
425 }
426 return true;
427 }
428
testAppendOperator()429 bool testAppendOperator()
430 {
431 string str1;
432 const char *text = "You spin my head right round.";
433
434 str1 += text;
435 EXPECT_TRUE(str1 == text);
436
437 str1 += " Flo Rida.";
438 EXPECT_TRUE(str1 == "You spin my head right round. Flo Rida.");
439
440 string str2;
441 str2 += str1;
442 EXPECT_TRUE(str2 == "You spin my head right round. Flo Rida.");
443
444 string str3("You spin ");
445 str3 += "my head right round.";
446 EXPECT_TRUE(str3 == "You spin my head right round.");
447
448 string str4("You spin ");
449 string str5("my head right round.");
450 str4 += str5;
451 EXPECT_TRUE(str4 == "You spin my head right round.");
452
453 string str6("");
454 string str7("");
455 str6 += str7;
456 EXPECT_TRUE(str6 == "");
457 EXPECT_TRUE(str6.empty());
458
459 string str8;
460 str8 += "a";
461 EXPECT_TRUE(str8 == "a");
462
463 const char more_text[] = {'l','a','d','y',' ','g','a','g','a'};
464
465 string str9;
466 for (size_t i = 0; i < ARRAYSIZE(more_text); ++i)
467 {
468 str9 += more_text[i];
469 }
470 EXPECT_TRUE(str9 == "lady gaga");
471
472 str9 += (const char *)NULL;
473 EXPECT_TRUE(str9 == "lady gaga");
474
475 string str10(more_text, ARRAYSIZE(more_text));
476 EXPECT_TRUE(str10 == "lady gaga");
477 str10 += '\0';
478 EXPECT_TRUE(str10 == "lady gaga");
479 EXPECT_TRUE(str10 == string("lady gaga\0", 10));
480 str10 += 'x';
481 EXPECT_TRUE(str10 == string("lady gaga\0x", 11));
482 EXPECT_TRUE(str10[11] == '\0');
483
484 return true;
485 }
486
487
testCompare()488 bool testCompare()
489 {
490 string str01("bell helmet");
491 string str02("bell moto");
492 string str03("bell");
493 string str04("bell pants");
494 string str05;
495
496 str05 = str01;
497 // Compare with self.
498 EXPECT_TRUE(str01 == str01);
499 EXPECT_TRUE(!(str01 != str01));
500
501 EXPECT_TRUE(str01 == str05);
502 EXPECT_TRUE(str05 == str01);
503 EXPECT_TRUE(!(str01 != str05));
504 EXPECT_TRUE(!(str05 != str01));
505
506 EXPECT_TRUE(str01 != str02);
507 EXPECT_TRUE(str01 != str03);
508 EXPECT_TRUE(str01 != str04);
509
510 // Compare with literals.
511 EXPECT_TRUE(str01 == "bell helmet");
512 EXPECT_TRUE(!(str01 != "bell helmet"));
513 EXPECT_TRUE("bell helmet" == str01);
514 EXPECT_TRUE(!("bell helmet" != str01));
515
516 // Compare with char array.
517 char array[] = { 'a', ' ', 'b', 'u', 'g', '\0'};
518 str01 = "a bug";
519 EXPECT_TRUE(array == str01);
520
521 EXPECT_TRUE(strcmp("a bug", "a bugg") < 0);
522
523 char array2[] = { 'a', 'b', 'u', 'g', 'g' };
524 EXPECT_TRUE(str01.compare(array2) < 0);
525
526 string str06;
527 EXPECT_TRUE(str06 != NULL);
528 {
529 string str_long("this is");
530 string str_short("it");
531 EXPECT_TRUE(str_long > str_short);
532 EXPECT_TRUE(str_long >= str_short);
533 EXPECT_FALSE(str_long < str_short);
534 EXPECT_FALSE(str_long <= str_short);
535 }
536 {
537 string str_lhs("this is");
538 string str_rhs("this is");
539 EXPECT_FALSE(str_lhs > str_rhs);
540 EXPECT_TRUE(str_lhs >= str_rhs);
541 EXPECT_FALSE(str_lhs < str_rhs);
542 EXPECT_TRUE(str_lhs <= str_rhs);
543 }
544 return true;
545 }
546
testSwap()547 bool testSwap()
548 {
549 string str01;
550 string str02("test");
551
552 str01.swap(str02);
553 EXPECT_TRUE(str02.empty());
554 EXPECT_TRUE(str01 == "test");
555
556 string str03("altima");
557 string str04("versa");
558 str03.swap(str04);
559 EXPECT_TRUE(str03 == "versa");
560 EXPECT_TRUE(str04 == "altima");
561
562 {
563 string empty;
564 // swap can be used to clean strings
565 str04.swap(empty);
566 }
567 EXPECT_TRUE(str04.empty());
568
569 return true;
570 }
571
testAccessor()572 bool testAccessor()
573 {
574 string str01 = "earmarks";
575
576 EXPECT_TRUE(str01[0] == 'e');
577 EXPECT_TRUE(str01[7] == 's');
578
579 str01[0] = 'E';
580 str01[7] = 'S';
581 EXPECT_TRUE(str01 == "EarmarkS");
582
583 for (int i = 0; i < 100; ++i)
584 {
585 string str02(i, 'x');
586
587 str02.reserve(20);
588
589 EXPECT_TRUE(str02[i] == '\0');
590
591 const string str03(str02);
592 EXPECT_TRUE(str03[i] == '\0');
593 }
594
595 string str05;
596 str05.reserve(100);
597 str05[99] = 'a';
598
599 // 'at'
600 EXPECT_TRUE(str01.at(0) == 'E');
601 EXPECT_TRUE(str01.at(7) == 'S');
602 EXPECT_TRUE(str01.at(8) == 'X'); // 'X' is the dummy value returned.
603
604 str01.at(1) = 'A';
605 str01.at(6) = 'K';
606 EXPECT_TRUE(str01 == "EArmarKS");
607 return true;
608 }
609
610
testAssignment()611 bool testAssignment()
612 {
613 const char *literal = "Need to buy a full face helmet for Lilie.";
614 const string str01 = literal;
615
616 EXPECT_TRUE(str01.length() == strlen(literal));
617 EXPECT_TRUE(str01.size() == strlen(literal));
618 EXPECT_TRUE(str01.capacity() == strlen(literal));
619 EXPECT_TRUE(str01 == literal);
620
621 string str02;
622
623 str02.assign(str01, 8, 33);
624 EXPECT_TRUE(str02 == "buy a full face helmet for Lilie.");
625
626 str02.assign(str01, 8, 0);
627 EXPECT_TRUE(str02 == "");
628
629 str02.assign(str01, 0, 7);
630 EXPECT_TRUE(str02 == "Need to");
631
632 str02.assign("unchanged");
633 str02.assign(str01, 35, 1000);
634 EXPECT_TRUE(str02 == "unchanged");
635
636 str02.assign(str01, 35, 6);
637 EXPECT_TRUE(str02 == "Lilie.");
638
639
640 str02.assign(str01, 35, 5);
641 EXPECT_TRUE(str02 == "Lilie");
642
643 string str03;
644
645 str03.assign(literal);
646 EXPECT_TRUE(str03 == "Need to buy a full face helmet for Lilie.");
647
648 string str04;
649
650 str04.assign(str03.c_str());
651 EXPECT_TRUE(str04 == "Need to buy a full face helmet for Lilie.");
652
653 str04.assign(str03.c_str() + 5, 10);
654 EXPECT_TRUE(str04 == "to buy a f");
655
656 str04.assign("noop");
657 str04.assign(NULL);
658 EXPECT_TRUE(str04 == "noop");
659
660 str04.assign(str01, str01.size() - 1, 1);
661 EXPECT_TRUE(str04 == ".");
662
663 str04.assign("unchanged");
664 str04.assign(str01, str01.size(), 1);
665 str04.assign(NULL, 4, 1);
666 str04.assign(NULL, 4);
667 EXPECT_TRUE(str04 == "unchanged");
668
669 return true;
670 }
671
testCopy()672 bool testCopy()
673 {
674 string data[] = {"one", "two", "three", "four", "five", "six"};
675 std::copy(data + 2, data + 5, data);
676 EXPECT_TRUE(data[0] == "three");
677 EXPECT_TRUE(data[1] == "four");
678 EXPECT_TRUE(data[2] == "five");
679 EXPECT_TRUE(data[3] == "four");
680 EXPECT_TRUE(data[4] == "five");
681 EXPECT_TRUE(data[5] == "six");
682 return true;
683 }
684
685
testConcat()686 bool testConcat()
687 {
688 string str01("The full");
689 string str02(" sentence.");
690 string str03;
691
692 str03 = str01 + str02;
693 EXPECT_TRUE(str03 == "The full sentence.");
694
695 str03 = str02 + str01;
696 EXPECT_TRUE(str03 == " sentence.The full");
697
698
699 str03 = str01 + " sentence.";
700 EXPECT_TRUE(str03 == "The full sentence.");
701
702 str03 = "The full" + str02;
703 EXPECT_TRUE(str03 == "The full sentence.");
704
705 str03 = 'l' + str02;
706 str03 = 'l' + str03;
707 str03 = 'u' + str03;
708 str03 = 'f' + str03;
709 str03 = ' ' + str03;
710 str03 = 'e' + str03;
711 str03 = 'h' + str03;
712 str03 = 'T' + str03;
713 EXPECT_TRUE(str03 == "The full sentence.");
714
715 str03 = "The full ";
716 str03 = str03 + 's';
717 str03 = str03 + 'e';
718 str03 = str03 + 'n';
719 str03 = str03 + 't';
720 str03 = str03 + 'e';
721 str03 = str03 + 'n';
722 str03 = str03 + 'c';
723 str03 = str03 + 'e';
724 str03 = str03 + '.';
725 EXPECT_TRUE(str03 == "The full sentence.");
726
727 // Check the new string buffer is not the same as the original one.
728 string str04("left and");
729 string str05(" right");
730 string str06(str04 + str05);
731
732 EXPECT_TRUE(str06 == "left and right");
733 EXPECT_TRUE(str06.c_str() != str04.c_str());
734 EXPECT_TRUE(str06.c_str() != str05.c_str());
735
736 str06 = str04 + str05;
737 EXPECT_TRUE(str06 == "left and right");
738 EXPECT_TRUE(str06.c_str() != str04.c_str());
739 EXPECT_TRUE(str06.c_str() != str05.c_str());
740 return true;
741 }
742
testPushBack()743 bool testPushBack()
744 {
745 string str01;
746
747 str01.push_back('a');
748 EXPECT_TRUE(str01 == "a");
749 EXPECT_TRUE(str01.capacity() == 1);
750
751 str01.reserve(10);
752 str01.push_back('b');
753 EXPECT_TRUE(str01 == "ab");
754 EXPECT_TRUE(str01.capacity() == 10);
755 EXPECT_TRUE(str01[2] == '\0');
756
757 str01.reserve();
758 EXPECT_TRUE(str01 == "ab");
759 EXPECT_TRUE(str01.capacity() == 2);
760 EXPECT_TRUE(str01[2] == '\0');
761
762 return true;
763 }
764
testFind()765 bool testFind()
766 {
767 string haystack("one two three one two three");
768
769 // Don't die on null strings
770 EXPECT_TRUE(haystack.find((char*)NULL) == string::npos);
771 EXPECT_TRUE(haystack.find((char*)NULL, 10) == string::npos);
772
773 // C strings.
774 EXPECT_TRUE(haystack.find("one") == 0);
775 EXPECT_TRUE(haystack.find("two") == 4);
776 EXPECT_TRUE(haystack.find("t") == 4);
777 EXPECT_TRUE(haystack.find("four") == string::npos);
778 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos);
779
780 // with offset
781 EXPECT_TRUE(haystack.find("one", 13) == 14);
782 EXPECT_TRUE(haystack.find("one", 14) == 14);
783 EXPECT_TRUE(haystack.find("one", 15) == string::npos);
784 EXPECT_TRUE(haystack.find("e", haystack.size() - 1) == haystack.size() - 1);
785 EXPECT_TRUE(haystack.find("e", haystack.size()) == string::npos);
786 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos);
787
788 // std::string
789 EXPECT_TRUE(haystack.find(string("one")) == 0);
790 EXPECT_TRUE(haystack.find(string("two")) == 4);
791 EXPECT_TRUE(haystack.find(string("t")) == 4);
792 EXPECT_TRUE(haystack.find(string("four")) == string::npos);
793 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos);
794
795 // with offset
796 EXPECT_TRUE(haystack.find(string("one"), 13) == 14);
797 EXPECT_TRUE(haystack.find(string("one"), 14) == 14);
798 EXPECT_TRUE(haystack.find(string("one"), 15) == string::npos);
799 EXPECT_TRUE(haystack.find(string("e"), haystack.size() - 1) == haystack.size() - 1);
800 EXPECT_TRUE(haystack.find(string("e"), haystack.size()) == string::npos);
801 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos);
802
803 // Emtpy string should be found at every position in a string except
804 // past the end.
805 EXPECT_TRUE(string().find("", 0) == 0);
806 EXPECT_TRUE(string().find(string(), 0) == 0);
807 EXPECT_TRUE(string().find(string(), 10) == string::npos);
808
809 string foo = "foo";
810 EXPECT_TRUE(foo.find("", 0) == 0);
811 EXPECT_TRUE(foo.find(string(), 0) == 0);
812 EXPECT_TRUE(foo.find(string(""), 0) == 0);
813
814 EXPECT_TRUE(foo.find("", 1) == 1);
815 EXPECT_TRUE(foo.find(string(), 1) == 1);
816 EXPECT_TRUE(foo.find(string(""), 1) == 1);
817
818 EXPECT_TRUE(foo.find("", foo.size()) == foo.size());
819 EXPECT_TRUE(foo.find(string(), foo.size()) == foo.size());
820 EXPECT_TRUE(foo.find(string(""), foo.size()) == foo.size());
821
822 EXPECT_TRUE(foo.find("", foo.size() + 1) == string::npos);
823 EXPECT_TRUE(foo.find(string(), foo.size() + 1) == string::npos);
824 EXPECT_TRUE(foo.find(string(""), foo.size() + 1) == string::npos);
825
826 // Find on an empty string a non empty one should fail
827 EXPECT_TRUE(string().find("f", 0) == string::npos);
828 EXPECT_TRUE(string().find(string("f"), 0) == string::npos);
829 return true;
830 }
831
testCapacity()832 bool testCapacity()
833 {
834 string empty_string;
835
836 EXPECT_TRUE(empty_string.capacity() == 0);
837 EXPECT_TRUE(empty_string.size() == 0);
838
839 const char *text = "non empty string";
840 const size_t len = strlen(text);
841 string str01(text);
842
843 EXPECT_TRUE(str01.capacity() == len);
844 EXPECT_TRUE(str01.size() == len);
845 return true;
846 }
847
testClear()848 bool testClear()
849 {
850 string empty_string;
851
852 empty_string.clear();
853 EXPECT_TRUE(empty_string.capacity() == 0);
854 EXPECT_TRUE(empty_string.size() == 0);
855
856 string str01("non empty string");
857
858 str01.clear();
859 EXPECT_TRUE(str01.capacity() == 0);
860 EXPECT_TRUE(str01.size() == 0);
861 EXPECT_TRUE(str01.empty());
862 return true;
863 }
864
testErase()865 bool testErase()
866 {
867 {
868 string empty_string;
869
870 empty_string.erase();
871 EXPECT_TRUE(empty_string.capacity() == 0);
872 EXPECT_TRUE(empty_string.size() == 0);
873
874 empty_string.erase(kMaxSizeT);
875 EXPECT_TRUE(empty_string.capacity() == 0);
876 EXPECT_TRUE(empty_string.size() == 0);
877
878 empty_string.erase(kMaxSizeT, kMaxSizeT);
879 EXPECT_TRUE(empty_string.capacity() == 0);
880 EXPECT_TRUE(empty_string.size() == 0);
881 }
882
883 {
884 string str01("a");
885
886 str01.erase();
887 EXPECT_TRUE(str01.capacity() == 1);
888 EXPECT_TRUE(str01.size() == 0);
889 }
890
891 {
892 string str02("a");
893
894 str02.erase(kMaxSizeT);
895 EXPECT_TRUE(str02.capacity() == 1);
896 EXPECT_TRUE(str02.size() == 1);
897 }
898
899 {
900 string str03("a");
901
902 str03.erase(0, kMaxSizeT);
903 EXPECT_TRUE(str03.capacity() == 1);
904 EXPECT_TRUE(str03.size() == 0);
905 }
906
907 {
908 string str04("a");
909
910 str04.erase(1, kMaxSizeT);
911 EXPECT_TRUE(str04.capacity() == 1);
912 EXPECT_TRUE(str04.size() == 1);
913 }
914
915 {
916 string str05("abcd");
917
918 str05.erase(1, 2);
919 EXPECT_TRUE(str05.capacity() == 4);
920 EXPECT_TRUE(str05.size() == 2);
921 EXPECT_TRUE(str05 == "ad");
922 }
923
924 {
925 string str06("abcd");
926
927 str06.erase(0, 1);
928 EXPECT_TRUE(str06.capacity() == 4);
929 EXPECT_TRUE(str06.size() == 3);
930 EXPECT_TRUE(str06 == "bcd");
931 }
932
933 {
934 // overlap
935 string str07("oh my god (You think I'm in control)");
936
937 str07.erase(0, strlen("oh my god "));
938 EXPECT_TRUE(str07.size() == 26);
939 EXPECT_TRUE(str07 == "(You think I'm in control)");
940 }
941
942 return true;
943 }
944
945 // Checks an iterator can be cast to a const one.
testConstIterator()946 bool testConstIterator()
947 {
948 string s("a string");
949 string::iterator i = s.begin();
950 string::const_iterator ci = s.begin();
951 return true;
952 }
953
testForwardIterator()954 bool testForwardIterator()
955 {
956 string s("a string");
957 char chars[] = "a string";
958 string::iterator iter = s.begin();
959 for (int i = 0; iter != s.end(); ++i) {
960 EXPECT_TRUE(*iter == chars[i]);
961 ++iter;
962 }
963 EXPECT_TRUE(iter == s.end());
964
965 string empty;
966 EXPECT_TRUE(empty.begin() == empty.end());
967 return true;
968 }
969
testSubstr()970 bool testSubstr() {
971 {
972 string s;
973 string res = s.substr(10, 1);
974 EXPECT_TRUE(res.empty());
975 }
976 {
977 string s = "pandora radio";
978 string res = s.substr(string::npos, 1);
979 EXPECT_TRUE(res.empty());
980 }
981 {
982 string s = "pandora radio";
983 string res = s.substr(5, 1000);
984 EXPECT_TRUE(res == "ra radio");
985 }
986 {
987 string s = "pandora radio";
988 string res = s.substr(5, 0);
989 EXPECT_TRUE(res.empty());
990 }
991 {
992 string s = "pandora radio";
993 string res = s.substr(5, 5);
994 EXPECT_TRUE(res == "ra ra");
995 }
996 return true;
997 }
998
testCharSearch()999 bool testCharSearch() {
1000 {
1001 string s;
1002 EXPECT_TRUE(s.find_first_of('a') == string::npos);
1003 s = "abracadabra";
1004 EXPECT_TRUE(s.find_first_of('a') == 0);
1005 EXPECT_TRUE(s.find_first_of('a', 0) == 0);
1006 EXPECT_TRUE(s.find_first_of('a', 1) == 3);
1007 EXPECT_TRUE(s.find_first_of('a', 8) == 10);
1008 s = "zzzzzzza";
1009 EXPECT_TRUE(s.find_first_of('a') == 7);
1010 EXPECT_TRUE(s.find_first_of('a', 8) == string::npos); // out of bound
1011 }
1012 // For char (set of size 1) find_first_of is equive to find(char, pos)
1013 {
1014 string s;
1015 EXPECT_TRUE(s.find('a') == string::npos);
1016 s = "abracadabra";
1017 EXPECT_TRUE(s.find('a') == 0);
1018 EXPECT_TRUE(s.find('a', 0) == 0);
1019 EXPECT_TRUE(s.find('a', 1) == 3);
1020 EXPECT_TRUE(s.find('a', 8) == 10);
1021 s = "zzzzzzza";
1022 EXPECT_TRUE(s.find('a') == 7);
1023 EXPECT_TRUE(s.find('a', 8) == string::npos); // out of bound
1024 }
1025 {
1026 string s;
1027 EXPECT_TRUE(s.find_last_of('a') == string::npos);
1028 EXPECT_TRUE(s.find_last_of('a', 0) == string::npos);
1029 EXPECT_TRUE(s.find_last_of('a', 10) == string::npos);
1030 s = "abracadabra";
1031 EXPECT_TRUE(s.find_last_of('a', 10) == 10);
1032 EXPECT_TRUE(s.find_last_of('a', 9) == 7);
1033 EXPECT_TRUE(s.find_last_of('a', 0) == 0);
1034 s = "azzzzzzz";
1035 EXPECT_TRUE(s.find_last_of('a') == 0);
1036 }
1037 // For char (set of size 1) find_last_of is equiv to rfind(char, pos).
1038 {
1039 string s;
1040 EXPECT_TRUE(s.rfind('a') == string::npos);
1041 EXPECT_TRUE(s.rfind('a', 0) == string::npos);
1042 EXPECT_TRUE(s.rfind('a', 10) == string::npos);
1043 s = "abracadabra";
1044 EXPECT_TRUE(s.rfind('a', 10) == 10);
1045 EXPECT_TRUE(s.rfind('a', 9) == 7);
1046 EXPECT_TRUE(s.rfind('a', 0) == 0);
1047 s = "azzzzzzz";
1048 EXPECT_TRUE(s.rfind('a') == 0);
1049 }
1050 {
1051 string s;
1052 EXPECT_TRUE(s.find_first_not_of('a') == string::npos);
1053 s = "abracadabra";
1054 EXPECT_TRUE(s.find_first_not_of('a') == 1);
1055 EXPECT_TRUE(s.find_first_not_of('a', 0) == 1);
1056 EXPECT_TRUE(s.find_first_not_of('a', 1) == 1);
1057 EXPECT_TRUE(s.find_first_not_of('a', 7) == 8);
1058 s = "zzzzzzza";
1059 EXPECT_TRUE(s.find_first_not_of('a') == 0);
1060 EXPECT_TRUE(s.find_first_not_of('a', 8) == string::npos); // out of bound
1061 }
1062 {
1063 string s;
1064 EXPECT_TRUE(s.find_last_not_of('a') == string::npos);
1065 EXPECT_TRUE(s.find_last_not_of('a', 0) == string::npos);
1066 EXPECT_TRUE(s.find_last_not_of('a', 10) == string::npos);
1067 s = "abracadabra";
1068 EXPECT_TRUE(s.find_last_not_of('a') == 9);
1069 EXPECT_TRUE(s.find_last_not_of('a', 10) == 9);
1070 EXPECT_TRUE(s.find_last_not_of('a', 9) == 9);
1071 EXPECT_TRUE(s.find_last_not_of('a', 0) == string::npos);
1072 s = "azzzzzzz";
1073 EXPECT_TRUE(s.find_last_not_of('a') == 7);
1074 }
1075 return true;
1076 }
1077
1078
testInsert()1079 bool testInsert() {
1080 {
1081 string::iterator res;
1082 string str("zzzzzz");
1083 res = str.insert(str.begin(), 'a');
1084 EXPECT_TRUE(str == "azzzzzz");
1085 EXPECT_TRUE(*res == 'a');
1086
1087 res = str.insert(str.begin() + 3, 'b');
1088 EXPECT_TRUE(str == "azzbzzzz");
1089 EXPECT_TRUE(*res == 'b');
1090
1091 res = str.insert(str.end(), 'c');
1092 EXPECT_TRUE(str == "azzbzzzzc");
1093 EXPECT_TRUE(*res == 'c');
1094 }
1095 {
1096 string str;
1097 string::iterator res = str.insert(str.begin(), 'a');
1098 EXPECT_TRUE(str == "a");
1099 EXPECT_TRUE(*res == 'a');
1100 }
1101 return true;
1102 }
1103
1104 } // namespace android
1105
main(int argc,char ** argv)1106 int main(int argc, char **argv)
1107 {
1108 FAIL_UNLESS(testConstructorCString);
1109 FAIL_UNLESS(testConstructorString);
1110 FAIL_UNLESS(testConstructorRepeatChar);
1111 FAIL_UNLESS(testConstructorPointers);
1112 FAIL_UNLESS(testConstructorInvalidValues);
1113 FAIL_UNLESS(testSize);
1114 FAIL_UNLESS(testCString);
1115 FAIL_UNLESS(testAppend);
1116 FAIL_UNLESS(testAppendOperator);
1117 FAIL_UNLESS(testConcat);
1118 FAIL_UNLESS(testAssignment);
1119 FAIL_UNLESS(testCopy);
1120 FAIL_UNLESS(testReserve);
1121 FAIL_UNLESS(testCompare);
1122 FAIL_UNLESS(testAccessor);
1123 FAIL_UNLESS(testSwap);
1124 FAIL_UNLESS(testPushBack);
1125 FAIL_UNLESS(testFind);
1126 FAIL_UNLESS(testCapacity);
1127 FAIL_UNLESS(testClear);
1128 FAIL_UNLESS(testErase);
1129 FAIL_UNLESS(testConstIterator);
1130 FAIL_UNLESS(testForwardIterator);
1131 FAIL_UNLESS(testSubstr);
1132 FAIL_UNLESS(testCharSearch);
1133 FAIL_UNLESS(testInsert);
1134 return kPassed;
1135 }
1136