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 "common.h"
37
38
39 namespace android {
40 using std::string;
41
testConstructorCString()42 bool testConstructorCString()
43 {
44 string empty_str1;
45 EXPECT_TRUE(empty_str1.size() == 0);
46 EXPECT_TRUE(empty_str1.capacity() == 0);
47
48 string empty_str2("");
49 EXPECT_TRUE(empty_str2.size() == 0);
50
51 const char empty_as_array[] = "";
52 string empty_str3(empty_as_array);
53 EXPECT_TRUE(empty_str3.size() == 0);
54
55 const char literal[] = "scott mills cracks me up";
56 string str1(literal);
57 EXPECT_TRUE(strcmp(literal, str1.c_str()) == 0);
58
59 string str2(literal, 11);
60 EXPECT_TRUE(strcmp("scott mills", str2.c_str()) == 0);
61
62 string str3(literal, sizeof(literal));
63 EXPECT_TRUE(strcmp(literal, str3.c_str()) == 0);
64
65 // Pass the end of the string => still ok, there is \0
66 string str4(literal, sizeof(literal) + 1);
67 EXPECT_TRUE(str4.size() == sizeof(literal) + 1);
68
69 string str5(literal, literal + 11);
70 EXPECT_TRUE(strcmp("scott mills", str5.c_str()) == 0);
71
72 const char text[] = {'l','a','d','y',' ','g','a','g','a'};
73
74 string str6(text, ARRAYSIZE(text));
75 EXPECT_TRUE(str6 == "lady gaga");
76
77 string str7(NULL);
78 EXPECT_TRUE(empty_str1.size() == 0);
79 EXPECT_TRUE(empty_str1.empty());
80 return true;
81 }
82
testConstructorString()83 bool testConstructorString()
84 {
85 string empty_str1;
86 string empty_str2;
87 EXPECT_TRUE(empty_str1.c_str() == empty_str2.c_str());
88
89 string empty_str3(empty_str2);
90 EXPECT_TRUE(empty_str3.size() == 0);
91
92 const char string_with_nulls[] = "contains 2 \0 bytes \0.";
93 string str1 (string_with_nulls, 21);
94 EXPECT_TRUE(str1.size() == 21);
95
96 string str2 (str1);
97 EXPECT_TRUE(str1.size() == 21);
98
99 const string str3("scott mills cracks me up");
100 string str4(str3, 12);
101 EXPECT_TRUE(strcmp("cracks me up", str4.c_str()) == 0);
102
103 string str5(str3, 12, 6);
104 EXPECT_TRUE(strcmp("cracks", str5.c_str()) == 0);
105
106 string str6(str3, 23);
107 EXPECT_TRUE(strcmp("p", str6.c_str()) == 0);
108
109 string str7(str3, 24);
110 EXPECT_TRUE(strcmp("", str7.c_str()) == 0);
111
112 string str8(str3, 23, 1);
113 EXPECT_TRUE(strcmp("p", str8.c_str()) == 0);
114
115 string str9(str3, 24, 1);
116 EXPECT_TRUE(strcmp("", str9.c_str()) == 0);
117
118 return true;
119 }
120
testConstructorPointers()121 bool testConstructorPointers()
122 {
123 const string empty;
124 char data[] = "a 16 char string";
125
126 string str01(data, data + 0);
127 EXPECT_TRUE(str01.c_str() == empty.c_str());
128
129 string str02(data, data + 1);
130 EXPECT_TRUE(str02 == "a");
131
132 string str03(data + 2, data + 16);
133 EXPECT_TRUE(str03 == "16 char string");
134
135 string str04(data + 15, data + 16);
136 EXPECT_TRUE(str04 == "g");
137
138 string str05(data + 16, data + 16);
139 EXPECT_TRUE(str05 == "");
140
141 return true;
142 }
143
testConstructorRepeatChar()144 bool testConstructorRepeatChar()
145 {
146 string str01(0, 'c');
147
148 EXPECT_TRUE(str01.empty());
149 EXPECT_TRUE(str01.size() == 0);
150 EXPECT_TRUE(str01.capacity() == 0);
151
152 string str02(10, 'c');
153
154 EXPECT_TRUE(!str02.empty());
155 EXPECT_TRUE(str02.size() == 10);
156 EXPECT_TRUE(str02.capacity() == 10);
157
158 for (size_t i = 0; i < 100; ++i)
159 {
160 string str03(i, 'x');
161
162 EXPECT_TRUE(str03[i] == '\0');
163 EXPECT_TRUE(str03.length() == i);
164
165 str03.reserve(i + 20);
166 EXPECT_TRUE(str03.capacity() == i + 20);
167 EXPECT_TRUE(str03.length() == i);
168 EXPECT_TRUE(str03[i] == '\0');
169 }
170
171 return true;
172 }
173
testConstructorInvalidValues()174 bool testConstructorInvalidValues()
175 {
176 const string empty;
177 const string str01("a 16 char string");
178
179 EXPECT_TRUE(str01.size() == 16);
180
181 string str02(str01, 17, 1); // invalid index
182 EXPECT_TRUE(str02.c_str() == empty.c_str());
183
184 string str03(str01, 17, 0); // invalid index
185 EXPECT_TRUE(str03.c_str() == empty.c_str());
186
187 string str04(str01, -1, 0); // invalid index
188 EXPECT_TRUE(str04.c_str() == empty.c_str());
189
190 string str05(str01, 0, 17); // invalid length
191 EXPECT_TRUE(str05.c_str() == empty.c_str());
192
193 string str06(str01, 17); // invalid index
194 EXPECT_TRUE(str06.c_str() == empty.c_str());
195
196 char end[] = "a string";
197 char *begin = end + 1; // begin after end.
198
199 string str07(begin, end);
200 EXPECT_TRUE(str07.c_str() == empty.c_str());
201
202 return true;
203 }
204
testSize()205 bool testSize()
206 {
207 string str01;
208 EXPECT_TRUE(str01.size() == 0);
209 EXPECT_TRUE(str01.length() == 0);
210
211 str01 += "a string.";
212
213 EXPECT_TRUE(str01.size() == 9);
214 EXPECT_TRUE(str01.length() == 9);
215
216 return true;
217 }
218
testCString()219 bool testCString()
220 {
221 string str01;
222 string str02;
223
224 // Should point to the same empty string.
225 EXPECT_TRUE(str01.c_str() == str02.c_str());
226 // c_str() == data()
227 EXPECT_TRUE(str01.c_str() == str01.data());
228 EXPECT_TRUE(str01.empty());
229
230 const char text[] = "a string";
231 str01 += text;
232 EXPECT_TRUE(strcmp(str01.c_str(), text) == 0);
233 EXPECT_TRUE(strcmp(str01.data(), text) == 0);
234 EXPECT_TRUE(!str01.empty());
235
236 // after a clear, points back to the original empty string.
237 str01.clear();
238 EXPECT_TRUE(str01.c_str() == str02.c_str());
239 EXPECT_TRUE(str01.empty());
240
241 return true;
242 }
243
testReserve()244 bool testReserve()
245 {
246 string str01;
247 size_t capacity = str01.capacity();
248
249 EXPECT_TRUE(0 == capacity);
250
251 str01.reserve(5);
252 EXPECT_TRUE(5 == str01.capacity());
253 str01.reserve(0);
254 EXPECT_TRUE(0 == str01.capacity());
255
256 string str02("7 chars");
257 EXPECT_TRUE(7 == str02.capacity());
258 EXPECT_TRUE(7 == str02.size());
259
260 str02.reserve(10);
261 EXPECT_TRUE(str02 == "7 chars");
262 EXPECT_TRUE(10 == str02.capacity());
263 EXPECT_TRUE(7 == str02.size());
264
265 str02.reserve(6); // no effect
266 EXPECT_TRUE(str02 == "7 chars");
267 EXPECT_TRUE(10 == str02.capacity());
268 EXPECT_TRUE(7 == str02.size());
269
270 string str03;
271 const string str04;
272
273 // Both point to kEmptyString.
274 EXPECT_TRUE(str03.c_str() == str04.c_str());
275
276 str03.reserve();
277 EXPECT_TRUE(0 == str03.capacity());
278 EXPECT_TRUE(str03.c_str() == str04.c_str());
279
280 str03.reserve(10);
281 EXPECT_TRUE(10 == str03.capacity());
282 // Not pointing at the empty string anymore.
283 EXPECT_TRUE(str03.c_str() != str04.c_str());
284
285 str03.reserve();
286 EXPECT_TRUE(0 == str03.capacity());
287 // c_str() points back to the empty string.
288 EXPECT_TRUE(str03.c_str() == str04.c_str());
289
290 str03.reserve(10);
291 str03.append("7 chars");
292 EXPECT_TRUE(str03 == "7 chars");
293 str03.reserve(); // shrink to fit.
294 EXPECT_TRUE(7 == str03.capacity());
295
296 string str05 = "twelve chars";
297 string str06 = str05;
298 str05.reserve(1);
299 EXPECT_TRUE(str05.capacity() == 12);
300
301
302 for (size_t i = 1; i <= 100; i *= 2)
303 {
304 string str(i, 'x');
305 str.reserve(3 * i);
306 EXPECT_TRUE(str.capacity() == 3 * i);
307
308 str.reserve(2 * i);
309 EXPECT_TRUE(str.capacity() == 2 * i);
310
311 str.reserve();
312 EXPECT_TRUE(str.capacity() == i);
313 }
314
315 // Check overflow.
316 string str07;
317
318 str07.reserve(10);
319 EXPECT_TRUE(str07.capacity() == 10);
320
321 str07.reserve(kMaxSizeT);
322
323 EXPECT_TRUE(str07.capacity() == 10);
324
325 return true;
326 }
327
testAppend()328 bool testAppend()
329 {
330 string str1;
331 const char *text = "You spin my head right round.";
332
333 str1.append(text);
334 EXPECT_TRUE(str1 == text);
335
336 str1.append(" Flo Rida.");
337 EXPECT_TRUE(str1 == "You spin my head right round. Flo Rida.");
338
339 string str2;
340 str2.append(str1);
341 EXPECT_TRUE(str2 == "You spin my head right round. Flo Rida.");
342
343 string str3("You spin ");
344 str3.append("my head right round.");
345 EXPECT_TRUE(str3 == "You spin my head right round.");
346
347 string str4("You spin ");
348 string str5("my head right round.");
349 str4.append(str5);
350 EXPECT_TRUE(str4 == "You spin my head right round.");
351
352 string str6("");
353 string str7("");
354 str6.append(str7);
355 EXPECT_TRUE(str6 == "");
356 EXPECT_TRUE(str6.empty());
357
358 string str8;
359 str8.append("a");
360 EXPECT_TRUE(str8 == "a");
361
362 const char more_text[] = {'l','a','d','y',' ','g','a','g','a'};
363
364 string str9;
365 str9.append(more_text, ARRAYSIZE(more_text));
366 EXPECT_TRUE(str9 == string(more_text, ARRAYSIZE(more_text)));
367
368 string str10;
369 str10.append("", 0);
370 EXPECT_TRUE(str10.size() == 0 );
371 str10.append(text, strlen(text));
372 EXPECT_TRUE(str10 == "You spin my head right round.");
373
374 string str11;
375 str11.append("You spin my head right round.", 5, 11);
376
377 EXPECT_TRUE(str11 == "pin my head");
378
379 // Append overflow
380 string str12("original");
381 char dummy[] = "unused";
382 // We lie about the size but that is ok. Since the lenght of the new string
383 // is going to be kMaxSizeT, the call will have not effect (there is no
384 // space for the trailing '\0').
385 str12.append(dummy, kMaxSizeT);
386 EXPECT_TRUE(str12 == "original");
387
388 return true;
389 }
390
testAppendOperator()391 bool testAppendOperator()
392 {
393 string str1;
394 const char *text = "You spin my head right round.";
395
396 str1 += text;
397 EXPECT_TRUE(str1 == text);
398
399 str1 += " Flo Rida.";
400 EXPECT_TRUE(str1 == "You spin my head right round. Flo Rida.");
401
402 string str2;
403 str2 += str1;
404 EXPECT_TRUE(str2 == "You spin my head right round. Flo Rida.");
405
406 string str3("You spin ");
407 str3 += "my head right round.";
408 EXPECT_TRUE(str3 == "You spin my head right round.");
409
410 string str4("You spin ");
411 string str5("my head right round.");
412 str4 += str5;
413 EXPECT_TRUE(str4 == "You spin my head right round.");
414
415 string str6("");
416 string str7("");
417 str6 += str7;
418 EXPECT_TRUE(str6 == "");
419 EXPECT_TRUE(str6.empty());
420
421 string str8;
422 str8 += "a";
423 EXPECT_TRUE(str8 == "a");
424
425 const char more_text[] = {'l','a','d','y',' ','g','a','g','a'};
426
427 string str9;
428 for (size_t i = 0; i < ARRAYSIZE(more_text); ++i)
429 {
430 str9 += more_text[i];
431 }
432 EXPECT_TRUE(str9 == "lady gaga");
433
434 str9 += (const char *)NULL;
435 EXPECT_TRUE(str9 == "lady gaga");
436
437 string str10(more_text, ARRAYSIZE(more_text));
438 EXPECT_TRUE(str10 == "lady gaga");
439 str10 += '\0';
440 EXPECT_TRUE(str10 == "lady gaga");
441 EXPECT_TRUE(str10 == string("lady gaga\0", 10));
442 str10 += 'x';
443 EXPECT_TRUE(str10 == string("lady gaga\0x", 11));
444 EXPECT_TRUE(str10[11] == '\0');
445
446 return true;
447 }
448
449
testCompare()450 bool testCompare()
451 {
452 string str01("bell helmet");
453 string str02("bell moto");
454 string str03("bell");
455 string str04("bell pants");
456 string str05;
457
458 str05 = str01;
459 // Compare with self.
460 EXPECT_TRUE(str01 == str01);
461 EXPECT_TRUE(!(str01 != str01));
462
463 EXPECT_TRUE(str01 == str05);
464 EXPECT_TRUE(str05 == str01);
465 EXPECT_TRUE(!(str01 != str05));
466 EXPECT_TRUE(!(str05 != str01));
467
468 EXPECT_TRUE(str01 != str02);
469 EXPECT_TRUE(str01 != str03);
470 EXPECT_TRUE(str01 != str04);
471
472 // Compare with literals.
473 EXPECT_TRUE(str01 == "bell helmet");
474 EXPECT_TRUE(!(str01 != "bell helmet"));
475 EXPECT_TRUE("bell helmet" == str01);
476 EXPECT_TRUE(!("bell helmet" != str01));
477
478 // Compare with char array.
479 char array[] = { 'a', ' ', 'b', 'u', 'g', '\0'};
480 str01 = "a bug";
481 EXPECT_TRUE(array == str01);
482
483 EXPECT_TRUE(strcmp("a bug", "a bugg") < 0);
484
485 char array2[] = { 'a', 'b', 'u', 'g', 'g' };
486 EXPECT_TRUE(str01.compare(array2) < 0);
487
488 string str06;
489 EXPECT_TRUE(str06 != NULL);
490 return true;
491 }
492
testSwap()493 bool testSwap()
494 {
495 string str01;
496 string str02("test");
497
498 str01.swap(str02);
499 EXPECT_TRUE(str02.empty());
500 EXPECT_TRUE(str01 == "test");
501
502 string str03("altima");
503 string str04("versa");
504 str03.swap(str04);
505 EXPECT_TRUE(str03 == "versa");
506 EXPECT_TRUE(str04 == "altima");
507
508 {
509 string empty;
510 // swap can be used to clean strings
511 str04.swap(empty);
512 }
513 EXPECT_TRUE(str04.empty());
514
515 return true;
516 }
517
testAccessor()518 bool testAccessor()
519 {
520 string str01 = "earmarks";
521
522 EXPECT_TRUE(str01[0] == 'e');
523 EXPECT_TRUE(str01[7] == 's');
524
525 str01[0] = 'E';
526 str01[7] = 'S';
527 EXPECT_TRUE(str01 == "EarmarkS");
528
529 for (int i = 0; i < 100; ++i)
530 {
531 string str02(i, 'x');
532
533 str02.reserve(20);
534
535 EXPECT_TRUE(str02[i] == '\0');
536
537 const string str03(str02);
538 EXPECT_TRUE(str03[i] == '\0');
539 }
540
541 string str05;
542 str05.reserve(100);
543 str05[99] = 'a';
544
545 return true;
546 }
547
548
testAssignment()549 bool testAssignment()
550 {
551 const char *literal = "Need to buy a full face helmet for Lilie.";
552 const string str01 = literal;
553
554 EXPECT_TRUE(str01.length() == strlen(literal));
555 EXPECT_TRUE(str01.size() == strlen(literal));
556 EXPECT_TRUE(str01.capacity() == strlen(literal));
557 EXPECT_TRUE(str01 == literal);
558
559 string str02;
560
561 str02.assign(str01, 8, 33);
562 EXPECT_TRUE(str02 == "buy a full face helmet for Lilie.");
563
564 str02.assign(str01, 8, 0);
565 EXPECT_TRUE(str02 == "");
566
567 str02.assign(str01, 0, 7);
568 EXPECT_TRUE(str02 == "Need to");
569
570 str02.assign("unchanged");
571 str02.assign(str01, 35, 1000);
572 EXPECT_TRUE(str02 == "unchanged");
573
574 str02.assign(str01, 35, 6);
575 EXPECT_TRUE(str02 == "Lilie.");
576
577
578 str02.assign(str01, 35, 5);
579 EXPECT_TRUE(str02 == "Lilie");
580
581 string str03;
582
583 str03.assign(literal);
584 EXPECT_TRUE(str03 == "Need to buy a full face helmet for Lilie.");
585
586 string str04;
587
588 str04.assign(str03.c_str());
589 EXPECT_TRUE(str04 == "Need to buy a full face helmet for Lilie.");
590
591 str04.assign(str03.c_str() + 5, 10);
592 EXPECT_TRUE(str04 == "to buy a f");
593
594 str04.assign("noop");
595 str04.assign(NULL);
596 EXPECT_TRUE(str04 == "noop");
597
598 str04.assign(str01, str01.size() - 1, 1);
599 EXPECT_TRUE(str04 == ".");
600
601 str04.assign("unchanged");
602 str04.assign(str01, str01.size(), 1);
603 str04.assign(NULL, 4, 1);
604 str04.assign(NULL, 4);
605 EXPECT_TRUE(str04 == "unchanged");
606
607 return true;
608 }
609
610
testConcat()611 bool testConcat()
612 {
613 string str01("The full");
614 string str02(" sentence.");
615 string str03;
616
617 str03 = str01 + str02;
618 EXPECT_TRUE(str03 == "The full sentence.");
619
620 str03 = str02 + str01;
621 EXPECT_TRUE(str03 == " sentence.The full");
622
623
624 str03 = str01 + " sentence.";
625 EXPECT_TRUE(str03 == "The full sentence.");
626
627 str03 = "The full" + str02;
628 EXPECT_TRUE(str03 == "The full sentence.");
629
630 str03 = 'l' + str02;
631 str03 = 'l' + str03;
632 str03 = 'u' + str03;
633 str03 = 'f' + str03;
634 str03 = ' ' + str03;
635 str03 = 'e' + str03;
636 str03 = 'h' + str03;
637 str03 = 'T' + str03;
638 EXPECT_TRUE(str03 == "The full sentence.");
639
640 str03 = "The full ";
641 str03 = str03 + 's';
642 str03 = str03 + 'e';
643 str03 = str03 + 'n';
644 str03 = str03 + 't';
645 str03 = str03 + 'e';
646 str03 = str03 + 'n';
647 str03 = str03 + 'c';
648 str03 = str03 + 'e';
649 str03 = str03 + '.';
650 EXPECT_TRUE(str03 == "The full sentence.");
651
652 // Check the new string buffer is not the same as the original one.
653 string str04("left and");
654 string str05(" right");
655 string str06(str04 + str05);
656
657 EXPECT_TRUE(str06 == "left and right");
658 EXPECT_TRUE(str06.c_str() != str04.c_str());
659 EXPECT_TRUE(str06.c_str() != str05.c_str());
660
661 str06 = str04 + str05;
662 EXPECT_TRUE(str06 == "left and right");
663 EXPECT_TRUE(str06.c_str() != str04.c_str());
664 EXPECT_TRUE(str06.c_str() != str05.c_str());
665 return true;
666 }
667
testPushBack()668 bool testPushBack()
669 {
670 string str01;
671
672 str01.push_back('a');
673 EXPECT_TRUE(str01 == "a");
674 EXPECT_TRUE(str01.capacity() == 1);
675
676 str01.reserve(10);
677 str01.push_back('b');
678 EXPECT_TRUE(str01 == "ab");
679 EXPECT_TRUE(str01.capacity() == 10);
680 EXPECT_TRUE(str01[2] == '\0');
681
682 str01.reserve();
683 EXPECT_TRUE(str01 == "ab");
684 EXPECT_TRUE(str01.capacity() == 2);
685 EXPECT_TRUE(str01[2] == '\0');
686
687 return true;
688 }
689
testFind()690 bool testFind()
691 {
692 string haystack("one two three one two three");
693
694 // Don't die on null strings
695 EXPECT_TRUE(haystack.find(NULL) == string::npos);
696 EXPECT_TRUE(haystack.find(NULL, 10) == string::npos);
697
698 // C strings.
699 EXPECT_TRUE(haystack.find("one") == 0);
700 EXPECT_TRUE(haystack.find("two") == 4);
701 EXPECT_TRUE(haystack.find("t") == 4);
702 EXPECT_TRUE(haystack.find("four") == string::npos);
703 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos);
704
705 // with offset
706 EXPECT_TRUE(haystack.find("one", 13) == 14);
707 EXPECT_TRUE(haystack.find("one", 14) == 14);
708 EXPECT_TRUE(haystack.find("one", 15) == string::npos);
709 EXPECT_TRUE(haystack.find("e", haystack.size() - 1) == haystack.size() - 1);
710 EXPECT_TRUE(haystack.find("e", haystack.size()) == string::npos);
711 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos);
712
713 // std::string
714 EXPECT_TRUE(haystack.find(string("one")) == 0);
715 EXPECT_TRUE(haystack.find(string("two")) == 4);
716 EXPECT_TRUE(haystack.find(string("t")) == 4);
717 EXPECT_TRUE(haystack.find(string("four")) == string::npos);
718 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos);
719
720 // with offset
721 EXPECT_TRUE(haystack.find(string("one"), 13) == 14);
722 EXPECT_TRUE(haystack.find(string("one"), 14) == 14);
723 EXPECT_TRUE(haystack.find(string("one"), 15) == string::npos);
724 EXPECT_TRUE(haystack.find(string("e"), haystack.size() - 1) == haystack.size() - 1);
725 EXPECT_TRUE(haystack.find(string("e"), haystack.size()) == string::npos);
726 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos);
727
728 // Emtpy string should be found at every position in a string except
729 // past the end.
730 EXPECT_TRUE(string().find("", 0) == 0);
731 EXPECT_TRUE(string().find(string(), 0) == 0);
732 EXPECT_TRUE(string().find(string(), 10) == string::npos);
733
734 string foo = "foo";
735 EXPECT_TRUE(foo.find("", 0) == 0);
736 EXPECT_TRUE(foo.find(string(), 0) == 0);
737 EXPECT_TRUE(foo.find(string(""), 0) == 0);
738
739 EXPECT_TRUE(foo.find("", 1) == 1);
740 EXPECT_TRUE(foo.find(string(), 1) == 1);
741 EXPECT_TRUE(foo.find(string(""), 1) == 1);
742
743 EXPECT_TRUE(foo.find("", foo.size()) == foo.size());
744 EXPECT_TRUE(foo.find(string(), foo.size()) == foo.size());
745 EXPECT_TRUE(foo.find(string(""), foo.size()) == foo.size());
746
747 EXPECT_TRUE(foo.find("", foo.size() + 1) == string::npos);
748 EXPECT_TRUE(foo.find(string(), foo.size() + 1) == string::npos);
749 EXPECT_TRUE(foo.find(string(""), foo.size() + 1) == string::npos);
750
751 // Find on an empty string a non empty one should fail
752 EXPECT_TRUE(string().find("f", 0) == string::npos);
753 EXPECT_TRUE(string().find(string("f"), 0) == string::npos);
754 return true;
755 }
756
testCapacity()757 bool testCapacity()
758 {
759 string empty_string;
760
761 EXPECT_TRUE(empty_string.capacity() == 0);
762 EXPECT_TRUE(empty_string.size() == 0);
763
764 const char *text = "non empty string";
765 const size_t len = strlen(text);
766 string str01(text);
767
768 EXPECT_TRUE(str01.capacity() == len);
769 EXPECT_TRUE(str01.size() == len);
770 return true;
771 }
772
testClear()773 bool testClear()
774 {
775 string empty_string;
776
777 empty_string.clear();
778 EXPECT_TRUE(empty_string.capacity() == 0);
779 EXPECT_TRUE(empty_string.size() == 0);
780
781 string str01("non empty string");
782
783 str01.clear();
784 EXPECT_TRUE(str01.capacity() == 0);
785 EXPECT_TRUE(str01.size() == 0);
786 EXPECT_TRUE(str01.empty());
787 return true;
788 }
789
testErase()790 bool testErase()
791 {
792 {
793 string empty_string;
794
795 empty_string.erase();
796 EXPECT_TRUE(empty_string.capacity() == 0);
797 EXPECT_TRUE(empty_string.size() == 0);
798
799 empty_string.erase(kMaxSizeT);
800 EXPECT_TRUE(empty_string.capacity() == 0);
801 EXPECT_TRUE(empty_string.size() == 0);
802
803 empty_string.erase(kMaxSizeT, kMaxSizeT);
804 EXPECT_TRUE(empty_string.capacity() == 0);
805 EXPECT_TRUE(empty_string.size() == 0);
806 }
807
808 {
809 string str01("a");
810
811 str01.erase();
812 EXPECT_TRUE(str01.capacity() == 1);
813 EXPECT_TRUE(str01.size() == 0);
814 }
815
816 {
817 string str02("a");
818
819 str02.erase(kMaxSizeT);
820 EXPECT_TRUE(str02.capacity() == 1);
821 EXPECT_TRUE(str02.size() == 1);
822 }
823
824 {
825 string str03("a");
826
827 str03.erase(0, kMaxSizeT);
828 EXPECT_TRUE(str03.capacity() == 1);
829 EXPECT_TRUE(str03.size() == 0);
830 }
831
832 {
833 string str04("a");
834
835 str04.erase(1, kMaxSizeT);
836 EXPECT_TRUE(str04.capacity() == 1);
837 EXPECT_TRUE(str04.size() == 1);
838 }
839
840 {
841 string str05("abcd");
842
843 str05.erase(1, 2);
844 EXPECT_TRUE(str05.capacity() == 4);
845 EXPECT_TRUE(str05.size() == 2);
846 EXPECT_TRUE(str05 == "ad");
847 }
848
849 {
850 string str06("abcd");
851
852 str06.erase(0, 1);
853 EXPECT_TRUE(str06.capacity() == 4);
854 EXPECT_TRUE(str06.size() == 3);
855 EXPECT_TRUE(str06 == "bcd");
856 }
857
858 {
859 // overlap
860 string str07("oh my god (You think I'm in control)");
861
862 str07.erase(0, strlen("oh my god "));
863 EXPECT_TRUE(str07.size() == 26);
864 EXPECT_TRUE(str07 == "(You think I'm in control)");
865 }
866
867 return true;
868 }
869
870 } // namespace android
871
main(int argc,char ** argv)872 int main(int argc, char **argv)
873 {
874 FAIL_UNLESS(testConstructorCString);
875 FAIL_UNLESS(testConstructorString);
876 FAIL_UNLESS(testConstructorRepeatChar);
877 FAIL_UNLESS(testConstructorPointers);
878 FAIL_UNLESS(testConstructorInvalidValues);
879 FAIL_UNLESS(testSize);
880 FAIL_UNLESS(testCString);
881 FAIL_UNLESS(testAppend);
882 FAIL_UNLESS(testAppendOperator);
883 FAIL_UNLESS(testConcat);
884 FAIL_UNLESS(testAssignment);
885 FAIL_UNLESS(testReserve);
886 FAIL_UNLESS(testCompare);
887 FAIL_UNLESS(testAccessor);
888 FAIL_UNLESS(testSwap);
889 FAIL_UNLESS(testPushBack);
890 FAIL_UNLESS(testFind);
891 FAIL_UNLESS(testCapacity);
892 FAIL_UNLESS(testClear);
893 FAIL_UNLESS(testErase);
894 return kPassed;
895 }
896