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