test_string.cpp revision 2a4077a9186d6f6dff104bbd1a73484aae6d5c01
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 return true; 546} 547 548 549bool 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 611bool 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 668bool 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 690bool 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 757bool 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 773bool 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 790bool 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 872int 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