test_string.cpp revision 464136e01a1facf09ce3befccbfc04f2d1da8d5b
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 -> clamped 192 EXPECT_TRUE(str05 == str01); 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 { 492 string str_long("this is"); 493 string str_short("it"); 494 EXPECT_TRUE(str_long > str_short); 495 EXPECT_TRUE(str_long >= str_short); 496 EXPECT_FALSE(str_long < str_short); 497 EXPECT_FALSE(str_long <= str_short); 498 } 499 { 500 string str_lhs("this is"); 501 string str_rhs("this is"); 502 EXPECT_FALSE(str_lhs > str_rhs); 503 EXPECT_TRUE(str_lhs >= str_rhs); 504 EXPECT_FALSE(str_lhs < str_rhs); 505 EXPECT_TRUE(str_lhs <= str_rhs); 506 } 507 return true; 508} 509 510bool testSwap() 511{ 512 string str01; 513 string str02("test"); 514 515 str01.swap(str02); 516 EXPECT_TRUE(str02.empty()); 517 EXPECT_TRUE(str01 == "test"); 518 519 string str03("altima"); 520 string str04("versa"); 521 str03.swap(str04); 522 EXPECT_TRUE(str03 == "versa"); 523 EXPECT_TRUE(str04 == "altima"); 524 525 { 526 string empty; 527 // swap can be used to clean strings 528 str04.swap(empty); 529 } 530 EXPECT_TRUE(str04.empty()); 531 532 return true; 533} 534 535bool testAccessor() 536{ 537 string str01 = "earmarks"; 538 539 EXPECT_TRUE(str01[0] == 'e'); 540 EXPECT_TRUE(str01[7] == 's'); 541 542 str01[0] = 'E'; 543 str01[7] = 'S'; 544 EXPECT_TRUE(str01 == "EarmarkS"); 545 546 for (int i = 0; i < 100; ++i) 547 { 548 string str02(i, 'x'); 549 550 str02.reserve(20); 551 552 EXPECT_TRUE(str02[i] == '\0'); 553 554 const string str03(str02); 555 EXPECT_TRUE(str03[i] == '\0'); 556 } 557 558 string str05; 559 str05.reserve(100); 560 str05[99] = 'a'; 561 562 // 'at' 563 EXPECT_TRUE(str01.at(0) == 'E'); 564 EXPECT_TRUE(str01.at(7) == 'S'); 565 EXPECT_TRUE(str01.at(8) == 'X'); // 'X' is the dummy value returned. 566 567 str01.at(1) = 'A'; 568 str01.at(6) = 'K'; 569 EXPECT_TRUE(str01 == "EArmarKS"); 570 return true; 571} 572 573 574bool testAssignment() 575{ 576 const char *literal = "Need to buy a full face helmet for Lilie."; 577 const string str01 = literal; 578 579 EXPECT_TRUE(str01.length() == strlen(literal)); 580 EXPECT_TRUE(str01.size() == strlen(literal)); 581 EXPECT_TRUE(str01.capacity() == strlen(literal)); 582 EXPECT_TRUE(str01 == literal); 583 584 string str02; 585 586 str02.assign(str01, 8, 33); 587 EXPECT_TRUE(str02 == "buy a full face helmet for Lilie."); 588 589 str02.assign(str01, 8, 0); 590 EXPECT_TRUE(str02 == ""); 591 592 str02.assign(str01, 0, 7); 593 EXPECT_TRUE(str02 == "Need to"); 594 595 str02.assign("unchanged"); 596 str02.assign(str01, 35, 1000); 597 EXPECT_TRUE(str02 == "unchanged"); 598 599 str02.assign(str01, 35, 6); 600 EXPECT_TRUE(str02 == "Lilie."); 601 602 603 str02.assign(str01, 35, 5); 604 EXPECT_TRUE(str02 == "Lilie"); 605 606 string str03; 607 608 str03.assign(literal); 609 EXPECT_TRUE(str03 == "Need to buy a full face helmet for Lilie."); 610 611 string str04; 612 613 str04.assign(str03.c_str()); 614 EXPECT_TRUE(str04 == "Need to buy a full face helmet for Lilie."); 615 616 str04.assign(str03.c_str() + 5, 10); 617 EXPECT_TRUE(str04 == "to buy a f"); 618 619 str04.assign("noop"); 620 str04.assign(NULL); 621 EXPECT_TRUE(str04 == "noop"); 622 623 str04.assign(str01, str01.size() - 1, 1); 624 EXPECT_TRUE(str04 == "."); 625 626 str04.assign("unchanged"); 627 str04.assign(str01, str01.size(), 1); 628 str04.assign(NULL, 4, 1); 629 str04.assign(NULL, 4); 630 EXPECT_TRUE(str04 == "unchanged"); 631 632 return true; 633} 634 635bool testCopy() 636{ 637 string data[] = {"one", "two", "three", "four", "five", "six"}; 638 std::copy(data + 2, data + 5, data); 639 EXPECT_TRUE(data[0] == "three"); 640 EXPECT_TRUE(data[1] == "four"); 641 EXPECT_TRUE(data[2] == "five"); 642 EXPECT_TRUE(data[3] == "four"); 643 EXPECT_TRUE(data[4] == "five"); 644 EXPECT_TRUE(data[5] == "six"); 645 return true; 646} 647 648 649bool testConcat() 650{ 651 string str01("The full"); 652 string str02(" sentence."); 653 string str03; 654 655 str03 = str01 + str02; 656 EXPECT_TRUE(str03 == "The full sentence."); 657 658 str03 = str02 + str01; 659 EXPECT_TRUE(str03 == " sentence.The full"); 660 661 662 str03 = str01 + " sentence."; 663 EXPECT_TRUE(str03 == "The full sentence."); 664 665 str03 = "The full" + str02; 666 EXPECT_TRUE(str03 == "The full sentence."); 667 668 str03 = 'l' + str02; 669 str03 = 'l' + str03; 670 str03 = 'u' + str03; 671 str03 = 'f' + str03; 672 str03 = ' ' + str03; 673 str03 = 'e' + str03; 674 str03 = 'h' + str03; 675 str03 = 'T' + str03; 676 EXPECT_TRUE(str03 == "The full sentence."); 677 678 str03 = "The full "; 679 str03 = str03 + 's'; 680 str03 = str03 + 'e'; 681 str03 = str03 + 'n'; 682 str03 = str03 + 't'; 683 str03 = str03 + 'e'; 684 str03 = str03 + 'n'; 685 str03 = str03 + 'c'; 686 str03 = str03 + 'e'; 687 str03 = str03 + '.'; 688 EXPECT_TRUE(str03 == "The full sentence."); 689 690 // Check the new string buffer is not the same as the original one. 691 string str04("left and"); 692 string str05(" right"); 693 string str06(str04 + str05); 694 695 EXPECT_TRUE(str06 == "left and right"); 696 EXPECT_TRUE(str06.c_str() != str04.c_str()); 697 EXPECT_TRUE(str06.c_str() != str05.c_str()); 698 699 str06 = str04 + str05; 700 EXPECT_TRUE(str06 == "left and right"); 701 EXPECT_TRUE(str06.c_str() != str04.c_str()); 702 EXPECT_TRUE(str06.c_str() != str05.c_str()); 703 return true; 704} 705 706bool testPushBack() 707{ 708 string str01; 709 710 str01.push_back('a'); 711 EXPECT_TRUE(str01 == "a"); 712 EXPECT_TRUE(str01.capacity() == 1); 713 714 str01.reserve(10); 715 str01.push_back('b'); 716 EXPECT_TRUE(str01 == "ab"); 717 EXPECT_TRUE(str01.capacity() == 10); 718 EXPECT_TRUE(str01[2] == '\0'); 719 720 str01.reserve(); 721 EXPECT_TRUE(str01 == "ab"); 722 EXPECT_TRUE(str01.capacity() == 2); 723 EXPECT_TRUE(str01[2] == '\0'); 724 725 return true; 726} 727 728bool testFind() 729{ 730 string haystack("one two three one two three"); 731 732 // Don't die on null strings 733 EXPECT_TRUE(haystack.find((char*)NULL) == string::npos); 734 EXPECT_TRUE(haystack.find((char*)NULL, 10) == string::npos); 735 736 // C strings. 737 EXPECT_TRUE(haystack.find("one") == 0); 738 EXPECT_TRUE(haystack.find("two") == 4); 739 EXPECT_TRUE(haystack.find("t") == 4); 740 EXPECT_TRUE(haystack.find("four") == string::npos); 741 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos); 742 743 // with offset 744 EXPECT_TRUE(haystack.find("one", 13) == 14); 745 EXPECT_TRUE(haystack.find("one", 14) == 14); 746 EXPECT_TRUE(haystack.find("one", 15) == string::npos); 747 EXPECT_TRUE(haystack.find("e", haystack.size() - 1) == haystack.size() - 1); 748 EXPECT_TRUE(haystack.find("e", haystack.size()) == string::npos); 749 EXPECT_TRUE(haystack.find("one", string::npos) == string::npos); 750 751 // std::string 752 EXPECT_TRUE(haystack.find(string("one")) == 0); 753 EXPECT_TRUE(haystack.find(string("two")) == 4); 754 EXPECT_TRUE(haystack.find(string("t")) == 4); 755 EXPECT_TRUE(haystack.find(string("four")) == string::npos); 756 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos); 757 758 // with offset 759 EXPECT_TRUE(haystack.find(string("one"), 13) == 14); 760 EXPECT_TRUE(haystack.find(string("one"), 14) == 14); 761 EXPECT_TRUE(haystack.find(string("one"), 15) == string::npos); 762 EXPECT_TRUE(haystack.find(string("e"), haystack.size() - 1) == haystack.size() - 1); 763 EXPECT_TRUE(haystack.find(string("e"), haystack.size()) == string::npos); 764 EXPECT_TRUE(haystack.find(string("one"), string::npos) == string::npos); 765 766 // Emtpy string should be found at every position in a string except 767 // past the end. 768 EXPECT_TRUE(string().find("", 0) == 0); 769 EXPECT_TRUE(string().find(string(), 0) == 0); 770 EXPECT_TRUE(string().find(string(), 10) == string::npos); 771 772 string foo = "foo"; 773 EXPECT_TRUE(foo.find("", 0) == 0); 774 EXPECT_TRUE(foo.find(string(), 0) == 0); 775 EXPECT_TRUE(foo.find(string(""), 0) == 0); 776 777 EXPECT_TRUE(foo.find("", 1) == 1); 778 EXPECT_TRUE(foo.find(string(), 1) == 1); 779 EXPECT_TRUE(foo.find(string(""), 1) == 1); 780 781 EXPECT_TRUE(foo.find("", foo.size()) == foo.size()); 782 EXPECT_TRUE(foo.find(string(), foo.size()) == foo.size()); 783 EXPECT_TRUE(foo.find(string(""), foo.size()) == foo.size()); 784 785 EXPECT_TRUE(foo.find("", foo.size() + 1) == string::npos); 786 EXPECT_TRUE(foo.find(string(), foo.size() + 1) == string::npos); 787 EXPECT_TRUE(foo.find(string(""), foo.size() + 1) == string::npos); 788 789 // Find on an empty string a non empty one should fail 790 EXPECT_TRUE(string().find("f", 0) == string::npos); 791 EXPECT_TRUE(string().find(string("f"), 0) == string::npos); 792 return true; 793} 794 795bool testCapacity() 796{ 797 string empty_string; 798 799 EXPECT_TRUE(empty_string.capacity() == 0); 800 EXPECT_TRUE(empty_string.size() == 0); 801 802 const char *text = "non empty string"; 803 const size_t len = strlen(text); 804 string str01(text); 805 806 EXPECT_TRUE(str01.capacity() == len); 807 EXPECT_TRUE(str01.size() == len); 808 return true; 809} 810 811bool testClear() 812{ 813 string empty_string; 814 815 empty_string.clear(); 816 EXPECT_TRUE(empty_string.capacity() == 0); 817 EXPECT_TRUE(empty_string.size() == 0); 818 819 string str01("non empty string"); 820 821 str01.clear(); 822 EXPECT_TRUE(str01.capacity() == 0); 823 EXPECT_TRUE(str01.size() == 0); 824 EXPECT_TRUE(str01.empty()); 825 return true; 826} 827 828bool testErase() 829{ 830 { 831 string empty_string; 832 833 empty_string.erase(); 834 EXPECT_TRUE(empty_string.capacity() == 0); 835 EXPECT_TRUE(empty_string.size() == 0); 836 837 empty_string.erase(kMaxSizeT); 838 EXPECT_TRUE(empty_string.capacity() == 0); 839 EXPECT_TRUE(empty_string.size() == 0); 840 841 empty_string.erase(kMaxSizeT, kMaxSizeT); 842 EXPECT_TRUE(empty_string.capacity() == 0); 843 EXPECT_TRUE(empty_string.size() == 0); 844 } 845 846 { 847 string str01("a"); 848 849 str01.erase(); 850 EXPECT_TRUE(str01.capacity() == 1); 851 EXPECT_TRUE(str01.size() == 0); 852 } 853 854 { 855 string str02("a"); 856 857 str02.erase(kMaxSizeT); 858 EXPECT_TRUE(str02.capacity() == 1); 859 EXPECT_TRUE(str02.size() == 1); 860 } 861 862 { 863 string str03("a"); 864 865 str03.erase(0, kMaxSizeT); 866 EXPECT_TRUE(str03.capacity() == 1); 867 EXPECT_TRUE(str03.size() == 0); 868 } 869 870 { 871 string str04("a"); 872 873 str04.erase(1, kMaxSizeT); 874 EXPECT_TRUE(str04.capacity() == 1); 875 EXPECT_TRUE(str04.size() == 1); 876 } 877 878 { 879 string str05("abcd"); 880 881 str05.erase(1, 2); 882 EXPECT_TRUE(str05.capacity() == 4); 883 EXPECT_TRUE(str05.size() == 2); 884 EXPECT_TRUE(str05 == "ad"); 885 } 886 887 { 888 string str06("abcd"); 889 890 str06.erase(0, 1); 891 EXPECT_TRUE(str06.capacity() == 4); 892 EXPECT_TRUE(str06.size() == 3); 893 EXPECT_TRUE(str06 == "bcd"); 894 } 895 896 { 897 // overlap 898 string str07("oh my god (You think I'm in control)"); 899 900 str07.erase(0, strlen("oh my god ")); 901 EXPECT_TRUE(str07.size() == 26); 902 EXPECT_TRUE(str07 == "(You think I'm in control)"); 903 } 904 905 return true; 906} 907 908// Checks an iterator can be cast to a const one. 909bool testConstIterator() 910{ 911 string s("a string"); 912 string::iterator i = s.begin(); 913 string::const_iterator ci = s.begin(); 914 return true; 915} 916 917bool testForwardIterator() 918{ 919 string s("a string"); 920 char chars[] = "a string"; 921 string::iterator iter = s.begin(); 922 for (int i = 0; iter != s.end(); ++i) { 923 EXPECT_TRUE(*iter == chars[i]); 924 ++iter; 925 } 926 EXPECT_TRUE(iter == s.end()); 927 928 string empty; 929 EXPECT_TRUE(empty.begin() == empty.end()); 930 return true; 931} 932 933bool testSubstr() { 934 { 935 string s; 936 string res = s.substr(10, 1); 937 EXPECT_TRUE(res.empty()); 938 } 939 { 940 string s = "pandora radio"; 941 string res = s.substr(string::npos, 1); 942 EXPECT_TRUE(res.empty()); 943 } 944 { 945 string s = "pandora radio"; 946 string res = s.substr(5, 1000); 947 EXPECT_TRUE(res == "ra radio"); 948 } 949 { 950 string s = "pandora radio"; 951 string res = s.substr(5, 0); 952 EXPECT_TRUE(res.empty()); 953 } 954 { 955 string s = "pandora radio"; 956 string res = s.substr(5, 5); 957 EXPECT_TRUE(res == "ra ra"); 958 } 959 return true; 960} 961 962bool testCharSearch() { 963 { 964 string s; 965 EXPECT_TRUE(s.find_first_of('a') == string::npos); 966 s = "abracadabra"; 967 EXPECT_TRUE(s.find_first_of('a') == 0); 968 EXPECT_TRUE(s.find_first_of('a', 0) == 0); 969 EXPECT_TRUE(s.find_first_of('a', 1) == 3); 970 EXPECT_TRUE(s.find_first_of('a', 8) == 10); 971 s = "zzzzzzza"; 972 EXPECT_TRUE(s.find_first_of('a') == 7); 973 EXPECT_TRUE(s.find_first_of('a', 8) == string::npos); // out of bound 974 } 975 // For char (set of size 1) find_first_of is equive to find(char, pos) 976 { 977 string s; 978 EXPECT_TRUE(s.find('a') == string::npos); 979 s = "abracadabra"; 980 EXPECT_TRUE(s.find('a') == 0); 981 EXPECT_TRUE(s.find('a', 0) == 0); 982 EXPECT_TRUE(s.find('a', 1) == 3); 983 EXPECT_TRUE(s.find('a', 8) == 10); 984 s = "zzzzzzza"; 985 EXPECT_TRUE(s.find('a') == 7); 986 EXPECT_TRUE(s.find('a', 8) == string::npos); // out of bound 987 } 988 { 989 string s; 990 EXPECT_TRUE(s.find_last_of('a') == string::npos); 991 EXPECT_TRUE(s.find_last_of('a', 0) == string::npos); 992 EXPECT_TRUE(s.find_last_of('a', 10) == string::npos); 993 s = "abracadabra"; 994 EXPECT_TRUE(s.find_last_of('a', 10) == 10); 995 EXPECT_TRUE(s.find_last_of('a', 9) == 7); 996 EXPECT_TRUE(s.find_last_of('a', 0) == 0); 997 s = "azzzzzzz"; 998 EXPECT_TRUE(s.find_last_of('a') == 0); 999 } 1000 // For char (set of size 1) find_last_of is equiv to rfind(char, pos). 1001 { 1002 string s; 1003 EXPECT_TRUE(s.rfind('a') == string::npos); 1004 EXPECT_TRUE(s.rfind('a', 0) == string::npos); 1005 EXPECT_TRUE(s.rfind('a', 10) == string::npos); 1006 s = "abracadabra"; 1007 EXPECT_TRUE(s.rfind('a', 10) == 10); 1008 EXPECT_TRUE(s.rfind('a', 9) == 7); 1009 EXPECT_TRUE(s.rfind('a', 0) == 0); 1010 s = "azzzzzzz"; 1011 EXPECT_TRUE(s.rfind('a') == 0); 1012 } 1013 { 1014 string s; 1015 EXPECT_TRUE(s.find_first_not_of('a') == string::npos); 1016 s = "abracadabra"; 1017 EXPECT_TRUE(s.find_first_not_of('a') == 1); 1018 EXPECT_TRUE(s.find_first_not_of('a', 0) == 1); 1019 EXPECT_TRUE(s.find_first_not_of('a', 1) == 1); 1020 EXPECT_TRUE(s.find_first_not_of('a', 7) == 8); 1021 s = "zzzzzzza"; 1022 EXPECT_TRUE(s.find_first_not_of('a') == 0); 1023 EXPECT_TRUE(s.find_first_not_of('a', 8) == string::npos); // out of bound 1024 } 1025 { 1026 string s; 1027 EXPECT_TRUE(s.find_last_not_of('a') == string::npos); 1028 EXPECT_TRUE(s.find_last_not_of('a', 0) == string::npos); 1029 EXPECT_TRUE(s.find_last_not_of('a', 10) == string::npos); 1030 s = "abracadabra"; 1031 EXPECT_TRUE(s.find_last_not_of('a') == 9); 1032 EXPECT_TRUE(s.find_last_not_of('a', 10) == 9); 1033 EXPECT_TRUE(s.find_last_not_of('a', 9) == 9); 1034 EXPECT_TRUE(s.find_last_not_of('a', 0) == string::npos); 1035 s = "azzzzzzz"; 1036 EXPECT_TRUE(s.find_last_not_of('a') == 7); 1037 } 1038 return true; 1039} 1040 1041 1042bool testInsert() { 1043 { 1044 string::iterator res; 1045 string str("zzzzzz"); 1046 res = str.insert(str.begin(), 'a'); 1047 EXPECT_TRUE(str == "azzzzzz"); 1048 EXPECT_TRUE(*res == 'a'); 1049 1050 res = str.insert(str.begin() + 3, 'b'); 1051 EXPECT_TRUE(str == "azzbzzzz"); 1052 EXPECT_TRUE(*res == 'b'); 1053 1054 res = str.insert(str.end(), 'c'); 1055 EXPECT_TRUE(str == "azzbzzzzc"); 1056 EXPECT_TRUE(*res == 'c'); 1057 } 1058 { 1059 string str; 1060 string::iterator res = str.insert(str.begin(), 'a'); 1061 EXPECT_TRUE(str == "a"); 1062 EXPECT_TRUE(*res == 'a'); 1063 } 1064 return true; 1065} 1066 1067} // namespace android 1068 1069int main(int argc, char **argv) 1070{ 1071 FAIL_UNLESS(testConstructorCString); 1072 FAIL_UNLESS(testConstructorString); 1073 FAIL_UNLESS(testConstructorRepeatChar); 1074 FAIL_UNLESS(testConstructorPointers); 1075 FAIL_UNLESS(testConstructorInvalidValues); 1076 FAIL_UNLESS(testSize); 1077 FAIL_UNLESS(testCString); 1078 FAIL_UNLESS(testAppend); 1079 FAIL_UNLESS(testAppendOperator); 1080 FAIL_UNLESS(testConcat); 1081 FAIL_UNLESS(testAssignment); 1082 FAIL_UNLESS(testCopy); 1083 FAIL_UNLESS(testReserve); 1084 FAIL_UNLESS(testCompare); 1085 FAIL_UNLESS(testAccessor); 1086 FAIL_UNLESS(testSwap); 1087 FAIL_UNLESS(testPushBack); 1088 FAIL_UNLESS(testFind); 1089 FAIL_UNLESS(testCapacity); 1090 FAIL_UNLESS(testClear); 1091 FAIL_UNLESS(testErase); 1092 FAIL_UNLESS(testConstIterator); 1093 FAIL_UNLESS(testForwardIterator); 1094 FAIL_UNLESS(testSubstr); 1095 FAIL_UNLESS(testCharSearch); 1096 FAIL_UNLESS(testInsert); 1097 return kPassed; 1098} 1099