test_string.cpp revision 74a6fdea77d52a17be4bc38831fe02a31cefbf34
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 39namespace android { 40using std::string; 41 42bool 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 83bool 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 121bool 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 144bool 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 174bool 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 205bool 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 219bool 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 244bool 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 328bool 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 391bool 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 450bool 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 493bool 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 518bool 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 // 'at' 546 EXPECT_TRUE(str01.at(0) == 'E'); 547 EXPECT_TRUE(str01.at(7) == 'S'); 548 EXPECT_TRUE(str01.at(8) == 'X'); // 'X' is the dummy value returned. 549 550 str01.at(1) = 'A'; 551 str01.at(6) = 'K'; 552 EXPECT_TRUE(str01 == "EArmarKS"); 553 return true; 554} 555 556 557bool testAssignment() 558{ 559 const char *literal = "Need to buy a full face helmet for Lilie."; 560 const string str01 = literal; 561 562 EXPECT_TRUE(str01.length() == strlen(literal)); 563 EXPECT_TRUE(str01.size() == strlen(literal)); 564 EXPECT_TRUE(str01.capacity() == strlen(literal)); 565 EXPECT_TRUE(str01 == literal); 566 567 string str02; 568 569 str02.assign(str01, 8, 33); 570 EXPECT_TRUE(str02 == "buy a full face helmet for Lilie."); 571 572 str02.assign(str01, 8, 0); 573 EXPECT_TRUE(str02 == ""); 574 575 str02.assign(str01, 0, 7); 576 EXPECT_TRUE(str02 == "Need to"); 577 578 str02.assign("unchanged"); 579 str02.assign(str01, 35, 1000); 580 EXPECT_TRUE(str02 == "unchanged"); 581 582 str02.assign(str01, 35, 6); 583 EXPECT_TRUE(str02 == "Lilie."); 584 585 586 str02.assign(str01, 35, 5); 587 EXPECT_TRUE(str02 == "Lilie"); 588 589 string str03; 590 591 str03.assign(literal); 592 EXPECT_TRUE(str03 == "Need to buy a full face helmet for Lilie."); 593 594 string str04; 595 596 str04.assign(str03.c_str()); 597 EXPECT_TRUE(str04 == "Need to buy a full face helmet for Lilie."); 598 599 str04.assign(str03.c_str() + 5, 10); 600 EXPECT_TRUE(str04 == "to buy a f"); 601 602 str04.assign("noop"); 603 str04.assign(NULL); 604 EXPECT_TRUE(str04 == "noop"); 605 606 str04.assign(str01, str01.size() - 1, 1); 607 EXPECT_TRUE(str04 == "."); 608 609 str04.assign("unchanged"); 610 str04.assign(str01, str01.size(), 1); 611 str04.assign(NULL, 4, 1); 612 str04.assign(NULL, 4); 613 EXPECT_TRUE(str04 == "unchanged"); 614 615 return true; 616} 617 618 619bool testConcat() 620{ 621 string str01("The full"); 622 string str02(" sentence."); 623 string str03; 624 625 str03 = str01 + str02; 626 EXPECT_TRUE(str03 == "The full sentence."); 627 628 str03 = str02 + str01; 629 EXPECT_TRUE(str03 == " sentence.The full"); 630 631 632 str03 = str01 + " sentence."; 633 EXPECT_TRUE(str03 == "The full sentence."); 634 635 str03 = "The full" + str02; 636 EXPECT_TRUE(str03 == "The full sentence."); 637 638 str03 = 'l' + str02; 639 str03 = 'l' + str03; 640 str03 = 'u' + str03; 641 str03 = 'f' + str03; 642 str03 = ' ' + str03; 643 str03 = 'e' + str03; 644 str03 = 'h' + str03; 645 str03 = 'T' + str03; 646 EXPECT_TRUE(str03 == "The full sentence."); 647 648 str03 = "The full "; 649 str03 = str03 + 's'; 650 str03 = str03 + 'e'; 651 str03 = str03 + 'n'; 652 str03 = str03 + 't'; 653 str03 = str03 + 'e'; 654 str03 = str03 + 'n'; 655 str03 = str03 + 'c'; 656 str03 = str03 + 'e'; 657 str03 = str03 + '.'; 658 EXPECT_TRUE(str03 == "The full sentence."); 659 660 // Check the new string buffer is not the same as the original one. 661 string str04("left and"); 662 string str05(" right"); 663 string str06(str04 + str05); 664 665 EXPECT_TRUE(str06 == "left and right"); 666 EXPECT_TRUE(str06.c_str() != str04.c_str()); 667 EXPECT_TRUE(str06.c_str() != str05.c_str()); 668 669 str06 = str04 + str05; 670 EXPECT_TRUE(str06 == "left and right"); 671 EXPECT_TRUE(str06.c_str() != str04.c_str()); 672 EXPECT_TRUE(str06.c_str() != str05.c_str()); 673 return true; 674} 675 676bool testPushBack() 677{ 678 string str01; 679 680 str01.push_back('a'); 681 EXPECT_TRUE(str01 == "a"); 682 EXPECT_TRUE(str01.capacity() == 1); 683 684 str01.reserve(10); 685 str01.push_back('b'); 686 EXPECT_TRUE(str01 == "ab"); 687 EXPECT_TRUE(str01.capacity() == 10); 688 EXPECT_TRUE(str01[2] == '\0'); 689 690 str01.reserve(); 691 EXPECT_TRUE(str01 == "ab"); 692 EXPECT_TRUE(str01.capacity() == 2); 693 EXPECT_TRUE(str01[2] == '\0'); 694 695 return true; 696} 697 698bool testFind() 699{ 700 string haystack("one two three one two three"); 701 702 // Don't die on null strings 703 EXPECT_TRUE(haystack.find(NULL) == string::npos); 704 EXPECT_TRUE(haystack.find(NULL, 10) == string::npos); 705 706 // C strings. 707 EXPECT_TRUE(haystack.find("one") == 0); 708 EXPECT_TRUE(haystack.find("two") == 4); 709 EXPECT_TRUE(haystack.find("t") == 4); 710 EXPECT_TRUE(haystack.find("four") == string::npos); 711 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos); 712 713 // with offset 714 EXPECT_TRUE(haystack.find("one", 13) == 14); 715 EXPECT_TRUE(haystack.find("one", 14) == 14); 716 EXPECT_TRUE(haystack.find("one", 15) == string::npos); 717 EXPECT_TRUE(haystack.find("e", haystack.size() - 1) == haystack.size() - 1); 718 EXPECT_TRUE(haystack.find("e", haystack.size()) == string::npos); 719 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos); 720 721 // std::string 722 EXPECT_TRUE(haystack.find(string("one")) == 0); 723 EXPECT_TRUE(haystack.find(string("two")) == 4); 724 EXPECT_TRUE(haystack.find(string("t")) == 4); 725 EXPECT_TRUE(haystack.find(string("four")) == string::npos); 726 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos); 727 728 // with offset 729 EXPECT_TRUE(haystack.find(string("one"), 13) == 14); 730 EXPECT_TRUE(haystack.find(string("one"), 14) == 14); 731 EXPECT_TRUE(haystack.find(string("one"), 15) == string::npos); 732 EXPECT_TRUE(haystack.find(string("e"), haystack.size() - 1) == haystack.size() - 1); 733 EXPECT_TRUE(haystack.find(string("e"), haystack.size()) == string::npos); 734 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos); 735 736 // Emtpy string should be found at every position in a string except 737 // past the end. 738 EXPECT_TRUE(string().find("", 0) == 0); 739 EXPECT_TRUE(string().find(string(), 0) == 0); 740 EXPECT_TRUE(string().find(string(), 10) == string::npos); 741 742 string foo = "foo"; 743 EXPECT_TRUE(foo.find("", 0) == 0); 744 EXPECT_TRUE(foo.find(string(), 0) == 0); 745 EXPECT_TRUE(foo.find(string(""), 0) == 0); 746 747 EXPECT_TRUE(foo.find("", 1) == 1); 748 EXPECT_TRUE(foo.find(string(), 1) == 1); 749 EXPECT_TRUE(foo.find(string(""), 1) == 1); 750 751 EXPECT_TRUE(foo.find("", foo.size()) == foo.size()); 752 EXPECT_TRUE(foo.find(string(), foo.size()) == foo.size()); 753 EXPECT_TRUE(foo.find(string(""), foo.size()) == foo.size()); 754 755 EXPECT_TRUE(foo.find("", foo.size() + 1) == string::npos); 756 EXPECT_TRUE(foo.find(string(), foo.size() + 1) == string::npos); 757 EXPECT_TRUE(foo.find(string(""), foo.size() + 1) == string::npos); 758 759 // Find on an empty string a non empty one should fail 760 EXPECT_TRUE(string().find("f", 0) == string::npos); 761 EXPECT_TRUE(string().find(string("f"), 0) == string::npos); 762 return true; 763} 764 765bool testCapacity() 766{ 767 string empty_string; 768 769 EXPECT_TRUE(empty_string.capacity() == 0); 770 EXPECT_TRUE(empty_string.size() == 0); 771 772 const char *text = "non empty string"; 773 const size_t len = strlen(text); 774 string str01(text); 775 776 EXPECT_TRUE(str01.capacity() == len); 777 EXPECT_TRUE(str01.size() == len); 778 return true; 779} 780 781bool testClear() 782{ 783 string empty_string; 784 785 empty_string.clear(); 786 EXPECT_TRUE(empty_string.capacity() == 0); 787 EXPECT_TRUE(empty_string.size() == 0); 788 789 string str01("non empty string"); 790 791 str01.clear(); 792 EXPECT_TRUE(str01.capacity() == 0); 793 EXPECT_TRUE(str01.size() == 0); 794 EXPECT_TRUE(str01.empty()); 795 return true; 796} 797 798bool testErase() 799{ 800 { 801 string empty_string; 802 803 empty_string.erase(); 804 EXPECT_TRUE(empty_string.capacity() == 0); 805 EXPECT_TRUE(empty_string.size() == 0); 806 807 empty_string.erase(kMaxSizeT); 808 EXPECT_TRUE(empty_string.capacity() == 0); 809 EXPECT_TRUE(empty_string.size() == 0); 810 811 empty_string.erase(kMaxSizeT, kMaxSizeT); 812 EXPECT_TRUE(empty_string.capacity() == 0); 813 EXPECT_TRUE(empty_string.size() == 0); 814 } 815 816 { 817 string str01("a"); 818 819 str01.erase(); 820 EXPECT_TRUE(str01.capacity() == 1); 821 EXPECT_TRUE(str01.size() == 0); 822 } 823 824 { 825 string str02("a"); 826 827 str02.erase(kMaxSizeT); 828 EXPECT_TRUE(str02.capacity() == 1); 829 EXPECT_TRUE(str02.size() == 1); 830 } 831 832 { 833 string str03("a"); 834 835 str03.erase(0, kMaxSizeT); 836 EXPECT_TRUE(str03.capacity() == 1); 837 EXPECT_TRUE(str03.size() == 0); 838 } 839 840 { 841 string str04("a"); 842 843 str04.erase(1, kMaxSizeT); 844 EXPECT_TRUE(str04.capacity() == 1); 845 EXPECT_TRUE(str04.size() == 1); 846 } 847 848 { 849 string str05("abcd"); 850 851 str05.erase(1, 2); 852 EXPECT_TRUE(str05.capacity() == 4); 853 EXPECT_TRUE(str05.size() == 2); 854 EXPECT_TRUE(str05 == "ad"); 855 } 856 857 { 858 string str06("abcd"); 859 860 str06.erase(0, 1); 861 EXPECT_TRUE(str06.capacity() == 4); 862 EXPECT_TRUE(str06.size() == 3); 863 EXPECT_TRUE(str06 == "bcd"); 864 } 865 866 { 867 // overlap 868 string str07("oh my god (You think I'm in control)"); 869 870 str07.erase(0, strlen("oh my god ")); 871 EXPECT_TRUE(str07.size() == 26); 872 EXPECT_TRUE(str07 == "(You think I'm in control)"); 873 } 874 875 return true; 876} 877 878// Checks an iterator can be cast to a const one. 879bool testConstIterator() 880{ 881 string s("a string"); 882 string::iterator i = s.begin(); 883 string::const_iterator ci = s.begin(); 884 return true; 885} 886 887bool testForwardIterator() 888{ 889 string s("a string"); 890 char chars[] = "a string"; 891 string::iterator iter = s.begin(); 892 for (int i = 0; iter != s.end(); ++i) { 893 EXPECT_TRUE(*iter == chars[i]); 894 ++iter; 895 } 896 EXPECT_TRUE(iter == s.end()); 897 898 string empty; 899 EXPECT_TRUE(empty.begin() == empty.end()); 900 return true; 901} 902 903} // namespace android 904 905int main(int argc, char **argv) 906{ 907 FAIL_UNLESS(testConstructorCString); 908 FAIL_UNLESS(testConstructorString); 909 FAIL_UNLESS(testConstructorRepeatChar); 910 FAIL_UNLESS(testConstructorPointers); 911 FAIL_UNLESS(testConstructorInvalidValues); 912 FAIL_UNLESS(testSize); 913 FAIL_UNLESS(testCString); 914 FAIL_UNLESS(testAppend); 915 FAIL_UNLESS(testAppendOperator); 916 FAIL_UNLESS(testConcat); 917 FAIL_UNLESS(testAssignment); 918 FAIL_UNLESS(testReserve); 919 FAIL_UNLESS(testCompare); 920 FAIL_UNLESS(testAccessor); 921 FAIL_UNLESS(testSwap); 922 FAIL_UNLESS(testPushBack); 923 FAIL_UNLESS(testFind); 924 FAIL_UNLESS(testCapacity); 925 FAIL_UNLESS(testClear); 926 FAIL_UNLESS(testErase); 927 FAIL_UNLESS(testConstIterator); 928 FAIL_UNLESS(testForwardIterator); 929 return kPassed; 930} 931