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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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. 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 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 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 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 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 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