OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <string> | 5 #include <string> |
6 | 6 |
7 #include "base/string16.h" | 7 #include "base/string16.h" |
8 #include "base/string_piece.h" | 8 #include "base/string_piece.h" |
9 #include "base/utf_string_conversions.h" | 9 #include "base/utf_string_conversions.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
11 | 11 |
12 namespace base { | 12 namespace base { |
13 | 13 |
14 TEST(StringPieceTest, CheckComparisonOperators) { | 14 template <typename T> |
15 #define CMP_Y(op, x, y) \ | 15 class CommonStringPieceTest : public ::testing::Test { |
16 ASSERT_TRUE( (StringPiece((x)) op StringPiece((y)))); \ | 16 public: |
17 ASSERT_TRUE( (StringPiece((x)).compare(StringPiece((y))) op 0)) | 17 static const T as_string(const char* input) { |
| 18 return T(input); |
| 19 } |
| 20 static const T& as_string(const T& input) { |
| 21 return input; |
| 22 } |
| 23 }; |
18 | 24 |
19 #define CMP_N(op, x, y) \ | 25 template <> |
20 ASSERT_FALSE(StringPiece((x)) op StringPiece((y))); \ | 26 class CommonStringPieceTest<string16> : public ::testing::Test { |
21 ASSERT_FALSE(StringPiece((x)).compare(StringPiece((y))) op 0) | 27 public: |
| 28 static const string16 as_string(const char* input) { |
| 29 return ASCIIToUTF16(input); |
| 30 } |
| 31 static const string16 as_string(const std::string& input) { |
| 32 return ASCIIToUTF16(input); |
| 33 } |
| 34 }; |
| 35 |
| 36 typedef ::testing::Types<std::string, string16> SupportedStringTypes; |
| 37 |
| 38 TYPED_TEST_CASE(CommonStringPieceTest, SupportedStringTypes); |
| 39 |
| 40 TYPED_TEST(CommonStringPieceTest, CheckComparisonOperators) { |
| 41 #define CMP_Y(op, x, y) \ |
| 42 { \ |
| 43 TypeParam lhs(TestFixture::as_string(x)); \ |
| 44 TypeParam rhs(TestFixture::as_string(y)); \ |
| 45 ASSERT_TRUE( (BasicStringPiece<TypeParam>((lhs.c_str())) op \ |
| 46 BasicStringPiece<TypeParam>((rhs.c_str())))); \ |
| 47 ASSERT_TRUE( (BasicStringPiece<TypeParam>((lhs.c_str())).compare( \ |
| 48 BasicStringPiece<TypeParam>((rhs.c_str()))) op 0)); \ |
| 49 } |
| 50 |
| 51 #define CMP_N(op, x, y) \ |
| 52 { \ |
| 53 TypeParam lhs(TestFixture::as_string(x)); \ |
| 54 TypeParam rhs(TestFixture::as_string(y)); \ |
| 55 ASSERT_FALSE( (BasicStringPiece<TypeParam>((lhs.c_str())) op \ |
| 56 BasicStringPiece<TypeParam>((rhs.c_str())))); \ |
| 57 ASSERT_FALSE( (BasicStringPiece<TypeParam>((lhs.c_str())).compare( \ |
| 58 BasicStringPiece<TypeParam>((rhs.c_str()))) op 0)); \ |
| 59 } |
22 | 60 |
23 CMP_Y(==, "", ""); | 61 CMP_Y(==, "", ""); |
24 CMP_Y(==, "a", "a"); | 62 CMP_Y(==, "a", "a"); |
25 CMP_Y(==, "aa", "aa"); | 63 CMP_Y(==, "aa", "aa"); |
26 CMP_N(==, "a", ""); | 64 CMP_N(==, "a", ""); |
27 CMP_N(==, "", "a"); | 65 CMP_N(==, "", "a"); |
28 CMP_N(==, "a", "b"); | 66 CMP_N(==, "a", "b"); |
29 CMP_N(==, "a", "aa"); | 67 CMP_N(==, "a", "aa"); |
30 CMP_N(==, "aa", "a"); | 68 CMP_N(==, "aa", "a"); |
31 | 69 |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
87 std::string z = x; | 125 std::string z = x; |
88 z[j] = 'b'; // Differs in position 'j' | 126 z[j] = 'b'; // Differs in position 'j' |
89 CMP_N(==, x, z); | 127 CMP_N(==, x, z); |
90 } | 128 } |
91 } | 129 } |
92 | 130 |
93 #undef CMP_Y | 131 #undef CMP_Y |
94 #undef CMP_N | 132 #undef CMP_N |
95 } | 133 } |
96 | 134 |
97 TEST(StringPieceTest, CheckSTL) { | 135 TYPED_TEST(CommonStringPieceTest, CheckSTL) { |
98 StringPiece a("abcdefghijklmnopqrstuvwxyz"); | 136 TypeParam alphabet(TestFixture::as_string("abcdefghijklmnopqrstuvwxyz")); |
99 StringPiece b("abc"); | 137 TypeParam abc(TestFixture::as_string("abc")); |
100 StringPiece c("xyz"); | 138 TypeParam xyz(TestFixture::as_string("xyz")); |
101 StringPiece d("foobar"); | 139 TypeParam foobar(TestFixture::as_string("foobar")); |
102 StringPiece e; | |
103 std::string temp("123"); | |
104 temp += '\0'; | |
105 temp += "456"; | |
106 StringPiece f(temp); | |
107 | 140 |
108 ASSERT_EQ(a[6], 'g'); | 141 BasicStringPiece<TypeParam> a(alphabet); |
109 ASSERT_EQ(b[0], 'a'); | 142 BasicStringPiece<TypeParam> b(abc); |
110 ASSERT_EQ(c[2], 'z'); | 143 BasicStringPiece<TypeParam> c(xyz); |
111 ASSERT_EQ(f[3], '\0'); | 144 BasicStringPiece<TypeParam> d(foobar); |
112 ASSERT_EQ(f[5], '5'); | 145 BasicStringPiece<TypeParam> e; |
| 146 TypeParam temp(TestFixture::as_string("123")); |
| 147 temp += static_cast<typename TypeParam::value_type>(0); |
| 148 temp += TestFixture::as_string("456"); |
| 149 BasicStringPiece<TypeParam> f(temp); |
113 | 150 |
114 ASSERT_EQ(*d.data(), 'f'); | 151 ASSERT_EQ(a[6], static_cast<typename TypeParam::value_type>('g')); |
115 ASSERT_EQ(d.data()[5], 'r'); | 152 ASSERT_EQ(b[0], static_cast<typename TypeParam::value_type>('a')); |
| 153 ASSERT_EQ(c[2], static_cast<typename TypeParam::value_type>('z')); |
| 154 ASSERT_EQ(f[3], static_cast<typename TypeParam::value_type>('\0')); |
| 155 ASSERT_EQ(f[5], static_cast<typename TypeParam::value_type>('5')); |
| 156 |
| 157 ASSERT_EQ(*d.data(), static_cast<typename TypeParam::value_type>('f')); |
| 158 ASSERT_EQ(d.data()[5], static_cast<typename TypeParam::value_type>('r')); |
116 ASSERT_TRUE(e.data() == NULL); | 159 ASSERT_TRUE(e.data() == NULL); |
117 | 160 |
118 ASSERT_EQ(*a.begin(), 'a'); | 161 ASSERT_EQ(*a.begin(), static_cast<typename TypeParam::value_type>('a')); |
119 ASSERT_EQ(*(b.begin() + 2), 'c'); | 162 ASSERT_EQ(*(b.begin() + 2), static_cast<typename TypeParam::value_type>('c')); |
120 ASSERT_EQ(*(c.end() - 1), 'z'); | 163 ASSERT_EQ(*(c.end() - 1), static_cast<typename TypeParam::value_type>('z')); |
121 | 164 |
122 ASSERT_EQ(*a.rbegin(), 'z'); | 165 ASSERT_EQ(*a.rbegin(), static_cast<typename TypeParam::value_type>('z')); |
123 ASSERT_EQ(*(b.rbegin() + 2), 'a'); | 166 ASSERT_EQ(*(b.rbegin() + 2), |
124 ASSERT_EQ(*(c.rend() - 1), 'x'); | 167 static_cast<typename TypeParam::value_type>('a')); |
| 168 ASSERT_EQ(*(c.rend() - 1), static_cast<typename TypeParam::value_type>('x')); |
125 ASSERT_TRUE(a.rbegin() + 26 == a.rend()); | 169 ASSERT_TRUE(a.rbegin() + 26 == a.rend()); |
126 | 170 |
127 ASSERT_EQ(a.size(), 26U); | 171 ASSERT_EQ(a.size(), 26U); |
128 ASSERT_EQ(b.size(), 3U); | 172 ASSERT_EQ(b.size(), 3U); |
129 ASSERT_EQ(c.size(), 3U); | 173 ASSERT_EQ(c.size(), 3U); |
130 ASSERT_EQ(d.size(), 6U); | 174 ASSERT_EQ(d.size(), 6U); |
131 ASSERT_EQ(e.size(), 0U); | 175 ASSERT_EQ(e.size(), 0U); |
132 ASSERT_EQ(f.size(), 7U); | 176 ASSERT_EQ(f.size(), 7U); |
133 | 177 |
134 ASSERT_TRUE(!d.empty()); | 178 ASSERT_TRUE(!d.empty()); |
135 ASSERT_TRUE(d.begin() != d.end()); | 179 ASSERT_TRUE(d.begin() != d.end()); |
136 ASSERT_TRUE(d.begin() + 6 == d.end()); | 180 ASSERT_TRUE(d.begin() + 6 == d.end()); |
137 | 181 |
138 ASSERT_TRUE(e.empty()); | 182 ASSERT_TRUE(e.empty()); |
139 ASSERT_TRUE(e.begin() == e.end()); | 183 ASSERT_TRUE(e.begin() == e.end()); |
140 | 184 |
141 d.clear(); | 185 d.clear(); |
142 ASSERT_EQ(d.size(), 0U); | 186 ASSERT_EQ(d.size(), 0U); |
143 ASSERT_TRUE(d.empty()); | 187 ASSERT_TRUE(d.empty()); |
144 ASSERT_TRUE(d.data() == NULL); | 188 ASSERT_TRUE(d.data() == NULL); |
145 ASSERT_TRUE(d.begin() == d.end()); | 189 ASSERT_TRUE(d.begin() == d.end()); |
146 | 190 |
147 ASSERT_GE(a.max_size(), a.capacity()); | 191 ASSERT_GE(a.max_size(), a.capacity()); |
148 ASSERT_GE(a.capacity(), a.size()); | 192 ASSERT_GE(a.capacity(), a.size()); |
| 193 } |
| 194 |
| 195 // STL stuff only supported by the std::string version |
| 196 TEST(StringPieceTest, CheckSTL) { |
| 197 StringPiece a("abcdefghijklmnopqrstuvwxyz"); |
| 198 StringPiece b("abc"); |
| 199 StringPiece c("xyz"); |
| 200 StringPiece d("foobar"); |
| 201 d.clear(); |
| 202 StringPiece e; |
| 203 std::string temp("123"); |
| 204 temp += '\0'; |
| 205 temp += "456"; |
| 206 StringPiece f(temp); |
149 | 207 |
150 char buf[4] = { '%', '%', '%', '%' }; | 208 char buf[4] = { '%', '%', '%', '%' }; |
151 ASSERT_EQ(a.copy(buf, 4), 4U); | 209 ASSERT_EQ(a.copy(buf, 4), 4U); |
152 ASSERT_EQ(buf[0], a[0]); | 210 ASSERT_EQ(buf[0], a[0]); |
153 ASSERT_EQ(buf[1], a[1]); | 211 ASSERT_EQ(buf[1], a[1]); |
154 ASSERT_EQ(buf[2], a[2]); | 212 ASSERT_EQ(buf[2], a[2]); |
155 ASSERT_EQ(buf[3], a[3]); | 213 ASSERT_EQ(buf[3], a[3]); |
156 ASSERT_EQ(a.copy(buf, 3, 7), 3U); | 214 ASSERT_EQ(a.copy(buf, 3, 7), 3U); |
157 ASSERT_EQ(buf[0], a[7]); | 215 ASSERT_EQ(buf[0], a[7]); |
158 ASSERT_EQ(buf[1], a[8]); | 216 ASSERT_EQ(buf[1], a[8]); |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
252 ASSERT_EQ(f.rfind('\0'), 3U); | 310 ASSERT_EQ(f.rfind('\0'), 3U); |
253 ASSERT_EQ(f.rfind('\0', 12), 3U); | 311 ASSERT_EQ(f.rfind('\0', 12), 3U); |
254 ASSERT_EQ(f.rfind('3'), 2U); | 312 ASSERT_EQ(f.rfind('3'), 2U); |
255 ASSERT_EQ(f.rfind('5'), 5U); | 313 ASSERT_EQ(f.rfind('5'), 5U); |
256 // empty string nonsense | 314 // empty string nonsense |
257 ASSERT_EQ(d.rfind('o'), StringPiece::npos); | 315 ASSERT_EQ(d.rfind('o'), StringPiece::npos); |
258 ASSERT_EQ(e.rfind('o'), StringPiece::npos); | 316 ASSERT_EQ(e.rfind('o'), StringPiece::npos); |
259 ASSERT_EQ(d.rfind('o', 4), StringPiece::npos); | 317 ASSERT_EQ(d.rfind('o', 4), StringPiece::npos); |
260 ASSERT_EQ(e.rfind('o', 7), StringPiece::npos); | 318 ASSERT_EQ(e.rfind('o', 7), StringPiece::npos); |
261 | 319 |
| 320 ASSERT_EQ( |
| 321 StringPiece("one,two:three;four").find_first_of(StringPiece(",:"), 1), |
| 322 3U); |
262 ASSERT_EQ(a.find_first_of(b), 0U); | 323 ASSERT_EQ(a.find_first_of(b), 0U); |
263 ASSERT_EQ(a.find_first_of(b, 0), 0U); | 324 ASSERT_EQ(a.find_first_of(b, 0), 0U); |
264 ASSERT_EQ(a.find_first_of(b, 1), 1U); | 325 ASSERT_EQ(a.find_first_of(b, 1), 1U); |
265 ASSERT_EQ(a.find_first_of(b, 2), 2U); | 326 ASSERT_EQ(a.find_first_of(b, 2), 2U); |
266 ASSERT_EQ(a.find_first_of(b, 3), StringPiece::npos); | 327 ASSERT_EQ(a.find_first_of(b, 3), StringPiece::npos); |
267 ASSERT_EQ(a.find_first_of(c), 23U); | 328 ASSERT_EQ(a.find_first_of(c), 23U); |
268 ASSERT_EQ(a.find_first_of(c, 23), 23U); | 329 ASSERT_EQ(a.find_first_of(c, 23), 23U); |
269 ASSERT_EQ(a.find_first_of(c, 24), 24U); | 330 ASSERT_EQ(a.find_first_of(c, 24), 24U); |
270 ASSERT_EQ(a.find_first_of(c, 25), 25U); | 331 ASSERT_EQ(a.find_first_of(c, 25), 25U); |
271 ASSERT_EQ(a.find_first_of(c, 26), StringPiece::npos); | 332 ASSERT_EQ(a.find_first_of(c, 26), StringPiece::npos); |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
393 ASSERT_EQ(a.substr(23, 99), c); | 454 ASSERT_EQ(a.substr(23, 99), c); |
394 ASSERT_EQ(a.substr(0), a); | 455 ASSERT_EQ(a.substr(0), a); |
395 ASSERT_EQ(a.substr(3, 2), "de"); | 456 ASSERT_EQ(a.substr(3, 2), "de"); |
396 // empty string nonsense | 457 // empty string nonsense |
397 ASSERT_EQ(a.substr(99, 2), e); | 458 ASSERT_EQ(a.substr(99, 2), e); |
398 ASSERT_EQ(d.substr(99), e); | 459 ASSERT_EQ(d.substr(99), e); |
399 ASSERT_EQ(d.substr(0, 99), e); | 460 ASSERT_EQ(d.substr(0, 99), e); |
400 ASSERT_EQ(d.substr(99, 99), e); | 461 ASSERT_EQ(d.substr(99, 99), e); |
401 } | 462 } |
402 | 463 |
| 464 TYPED_TEST(CommonStringPieceTest, CheckCustom) { |
| 465 TypeParam foobar(TestFixture::as_string("foobar")); |
| 466 BasicStringPiece<TypeParam> a(foobar); |
| 467 TypeParam s1(TestFixture::as_string("123")); |
| 468 s1 += static_cast<typename TypeParam::value_type>('\0'); |
| 469 s1 += TestFixture::as_string("456"); |
| 470 BasicStringPiece<TypeParam> b(s1); |
| 471 BasicStringPiece<TypeParam> e; |
| 472 TypeParam s2; |
| 473 |
| 474 // remove_prefix |
| 475 BasicStringPiece<TypeParam> c(a); |
| 476 c.remove_prefix(3); |
| 477 ASSERT_EQ(c, TestFixture::as_string("bar")); |
| 478 c = a; |
| 479 c.remove_prefix(0); |
| 480 ASSERT_EQ(c, a); |
| 481 c.remove_prefix(c.size()); |
| 482 ASSERT_EQ(c, e); |
| 483 |
| 484 // remove_suffix |
| 485 c = a; |
| 486 c.remove_suffix(3); |
| 487 ASSERT_EQ(c, TestFixture::as_string("foo")); |
| 488 c = a; |
| 489 c.remove_suffix(0); |
| 490 ASSERT_EQ(c, a); |
| 491 c.remove_suffix(c.size()); |
| 492 ASSERT_EQ(c, e); |
| 493 |
| 494 // set |
| 495 c.set(foobar.c_str()); |
| 496 ASSERT_EQ(c, a); |
| 497 c.set(foobar.c_str(), 6); |
| 498 ASSERT_EQ(c, a); |
| 499 c.set(foobar.c_str(), 0); |
| 500 ASSERT_EQ(c, e); |
| 501 c.set(foobar.c_str(), 7); // Note, has an embedded NULL |
| 502 ASSERT_NE(c, a); |
| 503 |
| 504 // as_string |
| 505 TypeParam s3(a.as_string().c_str(), 7); // Note, has an embedded NULL |
| 506 ASSERT_TRUE(c == s3); |
| 507 TypeParam s4(e.as_string()); |
| 508 ASSERT_TRUE(s4.empty()); |
| 509 } |
| 510 |
403 TEST(StringPieceTest, CheckCustom) { | 511 TEST(StringPieceTest, CheckCustom) { |
404 StringPiece a("foobar"); | 512 StringPiece a("foobar"); |
405 std::string s1("123"); | 513 std::string s1("123"); |
406 s1 += '\0'; | 514 s1 += '\0'; |
407 s1 += "456"; | 515 s1 += "456"; |
408 StringPiece b(s1); | 516 StringPiece b(s1); |
409 StringPiece e; | 517 StringPiece e; |
410 std::string s2; | 518 std::string s2; |
411 | 519 |
412 // CopyToString | 520 // CopyToString |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
445 ASSERT_TRUE(a.ends_with("bar")); | 553 ASSERT_TRUE(a.ends_with("bar")); |
446 ASSERT_TRUE(a.ends_with(e)); | 554 ASSERT_TRUE(a.ends_with(e)); |
447 ASSERT_TRUE(b.ends_with(s1)); | 555 ASSERT_TRUE(b.ends_with(s1)); |
448 ASSERT_TRUE(b.ends_with(b)); | 556 ASSERT_TRUE(b.ends_with(b)); |
449 ASSERT_TRUE(b.ends_with(e)); | 557 ASSERT_TRUE(b.ends_with(e)); |
450 ASSERT_TRUE(e.ends_with("")); | 558 ASSERT_TRUE(e.ends_with("")); |
451 ASSERT_TRUE(!a.ends_with(b)); | 559 ASSERT_TRUE(!a.ends_with(b)); |
452 ASSERT_TRUE(!b.ends_with(a)); | 560 ASSERT_TRUE(!b.ends_with(a)); |
453 ASSERT_TRUE(!e.ends_with(a)); | 561 ASSERT_TRUE(!e.ends_with(a)); |
454 | 562 |
455 // remove_prefix | 563 StringPiece c; |
456 StringPiece c(a); | |
457 c.remove_prefix(3); | |
458 ASSERT_EQ(c, "bar"); | |
459 c = a; | |
460 c.remove_prefix(0); | |
461 ASSERT_EQ(c, a); | |
462 c.remove_prefix(c.size()); | |
463 ASSERT_EQ(c, e); | |
464 | |
465 // remove_suffix | |
466 c = a; | |
467 c.remove_suffix(3); | |
468 ASSERT_EQ(c, "foo"); | |
469 c = a; | |
470 c.remove_suffix(0); | |
471 ASSERT_EQ(c, a); | |
472 c.remove_suffix(c.size()); | |
473 ASSERT_EQ(c, e); | |
474 | |
475 // set | |
476 c.set("foobar", 6); | |
477 ASSERT_EQ(c, a); | |
478 c.set("foobar", 0); | |
479 ASSERT_EQ(c, e); | |
480 c.set("foobar", 7); | |
481 ASSERT_NE(c, a); | |
482 | |
483 c.set("foobar"); | |
484 ASSERT_EQ(c, a); | |
485 | |
486 c.set(static_cast<const void*>("foobar"), 6); | 564 c.set(static_cast<const void*>("foobar"), 6); |
487 ASSERT_EQ(c, a); | 565 ASSERT_EQ(c, a); |
488 c.set(static_cast<const void*>("foobar"), 0); | 566 c.set(static_cast<const void*>("foobar"), 0); |
489 ASSERT_EQ(c, e); | 567 ASSERT_EQ(c, e); |
490 c.set(static_cast<const void*>("foobar"), 7); | 568 c.set(static_cast<const void*>("foobar"), 7); |
491 ASSERT_NE(c, a); | 569 ASSERT_NE(c, a); |
492 | |
493 // as_string | |
494 std::string s3(a.as_string().c_str(), 7); | |
495 ASSERT_EQ(c, s3); | |
496 std::string s4(e.as_string()); | |
497 ASSERT_TRUE(s4.empty()); | |
498 } | 570 } |
499 | 571 |
500 TEST(StringPieceTest, CheckNULL) { | 572 TYPED_TEST(CommonStringPieceTest, CheckNULL) { |
501 // we used to crash here, but now we don't. | 573 // we used to crash here, but now we don't. |
502 StringPiece s(NULL); | 574 BasicStringPiece<TypeParam> s(NULL); |
503 ASSERT_EQ(s.data(), (const char*)NULL); | 575 ASSERT_EQ(s.data(), (const typename TypeParam::value_type*)NULL); |
504 ASSERT_EQ(s.size(), 0U); | 576 ASSERT_EQ(s.size(), 0U); |
505 | 577 |
506 s.set(NULL); | 578 s.set(NULL); |
507 ASSERT_EQ(s.data(), (const char*)NULL); | 579 ASSERT_EQ(s.data(), (const typename TypeParam::value_type*)NULL); |
508 ASSERT_EQ(s.size(), 0U); | 580 ASSERT_EQ(s.size(), 0U); |
| 581 |
| 582 TypeParam str = s.as_string(); |
| 583 ASSERT_EQ(str.length(), 0U); |
| 584 ASSERT_EQ(str, TypeParam()); |
509 } | 585 } |
510 | 586 |
| 587 TYPED_TEST(CommonStringPieceTest, CheckComparisons2) { |
| 588 TypeParam alphabet(TestFixture::as_string("abcdefghijklmnopqrstuvwxyz")); |
| 589 TypeParam alphabet_z(TestFixture::as_string("abcdefghijklmnopqrstuvwxyzz")); |
| 590 TypeParam alphabet_y(TestFixture::as_string("abcdefghijklmnopqrstuvwxyy")); |
| 591 BasicStringPiece<TypeParam> abc(alphabet); |
| 592 |
| 593 // check comparison operations on strings longer than 4 bytes. |
| 594 ASSERT_TRUE(abc == BasicStringPiece<TypeParam>(alphabet)); |
| 595 ASSERT_TRUE(abc.compare(BasicStringPiece<TypeParam>(alphabet)) == 0); |
| 596 |
| 597 ASSERT_TRUE(abc < BasicStringPiece<TypeParam>(alphabet_z)); |
| 598 ASSERT_TRUE(abc.compare(BasicStringPiece<TypeParam>(alphabet_z)) < 0); |
| 599 |
| 600 ASSERT_TRUE(abc > BasicStringPiece<TypeParam>(alphabet_y)); |
| 601 ASSERT_TRUE(abc.compare(BasicStringPiece<TypeParam>(alphabet_y)) > 0); |
| 602 } |
| 603 |
| 604 // Test operations only supported by std::string version. |
511 TEST(StringPieceTest, CheckComparisons2) { | 605 TEST(StringPieceTest, CheckComparisons2) { |
512 StringPiece abc("abcdefghijklmnopqrstuvwxyz"); | 606 StringPiece abc("abcdefghijklmnopqrstuvwxyz"); |
513 | 607 |
514 // check comparison operations on strings longer than 4 bytes. | |
515 ASSERT_TRUE(abc == StringPiece("abcdefghijklmnopqrstuvwxyz")); | |
516 ASSERT_TRUE(abc.compare(StringPiece("abcdefghijklmnopqrstuvwxyz")) == 0); | |
517 | |
518 ASSERT_TRUE(abc < StringPiece("abcdefghijklmnopqrstuvwxzz")); | |
519 ASSERT_TRUE(abc.compare(StringPiece("abcdefghijklmnopqrstuvwxzz")) < 0); | |
520 | |
521 ASSERT_TRUE(abc > StringPiece("abcdefghijklmnopqrstuvwxyy")); | |
522 ASSERT_TRUE(abc.compare(StringPiece("abcdefghijklmnopqrstuvwxyy")) > 0); | |
523 | |
524 // starts_with | 608 // starts_with |
525 ASSERT_TRUE(abc.starts_with(abc)); | 609 ASSERT_TRUE(abc.starts_with(abc)); |
526 ASSERT_TRUE(abc.starts_with("abcdefghijklm")); | 610 ASSERT_TRUE(abc.starts_with("abcdefghijklm")); |
527 ASSERT_TRUE(!abc.starts_with("abcdefguvwxyz")); | 611 ASSERT_TRUE(!abc.starts_with("abcdefguvwxyz")); |
528 | 612 |
529 // ends_with | 613 // ends_with |
530 ASSERT_TRUE(abc.ends_with(abc)); | 614 ASSERT_TRUE(abc.ends_with(abc)); |
531 ASSERT_TRUE(!abc.ends_with("abcdefguvwxyz")); | 615 ASSERT_TRUE(!abc.ends_with("abcdefguvwxyz")); |
532 ASSERT_TRUE(abc.ends_with("nopqrstuvwxyz")); | 616 ASSERT_TRUE(abc.ends_with("nopqrstuvwxyz")); |
533 } | 617 } |
534 | 618 |
535 TEST(StringPieceTest, StringCompareNotAmbiguous) { | 619 TYPED_TEST(CommonStringPieceTest, StringCompareNotAmbiguous) { |
536 ASSERT_TRUE("hello" == std::string("hello")); | 620 ASSERT_TRUE(TestFixture::as_string("hello").c_str() == |
537 ASSERT_TRUE("hello" < std::string("world")); | 621 TestFixture::as_string("hello")); |
| 622 ASSERT_TRUE(TestFixture::as_string("hello").c_str() < |
| 623 TestFixture::as_string("world")); |
538 } | 624 } |
539 | 625 |
540 TEST(StringPieceTest, HeterogenousStringPieceEquals) { | 626 TYPED_TEST(CommonStringPieceTest, HeterogenousStringPieceEquals) { |
541 ASSERT_TRUE(StringPiece("hello") == std::string("hello")); | 627 TypeParam hello(TestFixture::as_string("hello")); |
542 ASSERT_TRUE("hello" == StringPiece("hello")); | 628 |
| 629 ASSERT_TRUE(BasicStringPiece<TypeParam>(hello) == hello); |
| 630 ASSERT_TRUE(hello.c_str() == BasicStringPiece<TypeParam>(hello)); |
543 } | 631 } |
544 | 632 |
545 TEST(StringPiece16Test, CheckComparisonOperators) { | 633 // string16-specific stuff |
546 ASSERT_TRUE(StringPiece16(string16()) == | |
547 StringPiece16(string16())); | |
548 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) == | |
549 StringPiece16(ASCIIToUTF16("a"))); | |
550 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) == | |
551 StringPiece16(ASCIIToUTF16("aa"))); | |
552 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) == | |
553 StringPiece16(string16())); | |
554 ASSERT_FALSE(StringPiece16(string16()) == | |
555 StringPiece16(ASCIIToUTF16("a"))); | |
556 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) == | |
557 StringPiece16(ASCIIToUTF16("b"))); | |
558 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) == | |
559 StringPiece16(ASCIIToUTF16("aa"))); | |
560 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) == | |
561 StringPiece16(ASCIIToUTF16("a"))); | |
562 | |
563 ASSERT_FALSE(StringPiece16(string16()) != | |
564 StringPiece16(string16())); | |
565 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) != | |
566 StringPiece16(ASCIIToUTF16("a"))); | |
567 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) != | |
568 StringPiece16(ASCIIToUTF16("aa"))); | |
569 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) != | |
570 StringPiece16(string16())); | |
571 ASSERT_TRUE(StringPiece16(string16()) != | |
572 StringPiece16(ASCIIToUTF16("a"))); | |
573 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) != | |
574 StringPiece16(ASCIIToUTF16("b"))); | |
575 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) != | |
576 StringPiece16(ASCIIToUTF16("aa"))); | |
577 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) != | |
578 StringPiece16(ASCIIToUTF16("a"))); | |
579 | |
580 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) < | |
581 StringPiece16(ASCIIToUTF16("b"))); | |
582 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) < | |
583 StringPiece16(ASCIIToUTF16("aa"))); | |
584 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) < | |
585 StringPiece16(ASCIIToUTF16("b"))); | |
586 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) < | |
587 StringPiece16(ASCIIToUTF16("bb"))); | |
588 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) < | |
589 StringPiece16(ASCIIToUTF16("a"))); | |
590 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("b")) < | |
591 StringPiece16(ASCIIToUTF16("a"))); | |
592 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) < | |
593 StringPiece16(ASCIIToUTF16("a"))); | |
594 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("b")) < | |
595 StringPiece16(ASCIIToUTF16("aa"))); | |
596 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("bb")) < | |
597 StringPiece16(ASCIIToUTF16("aa"))); | |
598 | |
599 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) <= | |
600 StringPiece16(ASCIIToUTF16("a"))); | |
601 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) <= | |
602 StringPiece16(ASCIIToUTF16("b"))); | |
603 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) <= | |
604 StringPiece16(ASCIIToUTF16("aa"))); | |
605 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) <= | |
606 StringPiece16(ASCIIToUTF16("b"))); | |
607 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) <= | |
608 StringPiece16(ASCIIToUTF16("bb"))); | |
609 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("b")) <= | |
610 StringPiece16(ASCIIToUTF16("a"))); | |
611 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) <= | |
612 StringPiece16(ASCIIToUTF16("a"))); | |
613 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("b")) <= | |
614 StringPiece16(ASCIIToUTF16("aa"))); | |
615 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("bb")) <= | |
616 StringPiece16(ASCIIToUTF16("aa"))); | |
617 | |
618 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) <= | |
619 StringPiece16(ASCIIToUTF16("a"))); | |
620 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) <= | |
621 StringPiece16(ASCIIToUTF16("b"))); | |
622 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) <= | |
623 StringPiece16(ASCIIToUTF16("aa"))); | |
624 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) <= | |
625 StringPiece16(ASCIIToUTF16("b"))); | |
626 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) <= | |
627 StringPiece16(ASCIIToUTF16("bb"))); | |
628 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("b")) <= | |
629 StringPiece16(ASCIIToUTF16("a"))); | |
630 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) <= | |
631 StringPiece16(ASCIIToUTF16("a"))); | |
632 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("b")) <= | |
633 StringPiece16(ASCIIToUTF16("aa"))); | |
634 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("bb")) <= | |
635 StringPiece16(ASCIIToUTF16("aa"))); | |
636 | |
637 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) >= | |
638 StringPiece16(ASCIIToUTF16("b"))); | |
639 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) >= | |
640 StringPiece16(ASCIIToUTF16("aa"))); | |
641 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) >= | |
642 StringPiece16(ASCIIToUTF16("b"))); | |
643 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) >= | |
644 StringPiece16(ASCIIToUTF16("bb"))); | |
645 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("a")) >= | |
646 StringPiece16(ASCIIToUTF16("a"))); | |
647 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("b")) >= | |
648 StringPiece16(ASCIIToUTF16("a"))); | |
649 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) >= | |
650 StringPiece16(ASCIIToUTF16("a"))); | |
651 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("b")) >= | |
652 StringPiece16(ASCIIToUTF16("aa"))); | |
653 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("bb")) >= | |
654 StringPiece16(ASCIIToUTF16("aa"))); | |
655 | |
656 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) > | |
657 StringPiece16(ASCIIToUTF16("a"))); | |
658 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) > | |
659 StringPiece16(ASCIIToUTF16("b"))); | |
660 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("a")) > | |
661 StringPiece16(ASCIIToUTF16("aa"))); | |
662 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) > | |
663 StringPiece16(ASCIIToUTF16("b"))); | |
664 ASSERT_FALSE(StringPiece16(ASCIIToUTF16("aa")) > | |
665 StringPiece16(ASCIIToUTF16("bb"))); | |
666 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("b")) > | |
667 StringPiece16(ASCIIToUTF16("a"))); | |
668 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("aa")) > | |
669 StringPiece16(ASCIIToUTF16("a"))); | |
670 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("b")) > | |
671 StringPiece16(ASCIIToUTF16("aa"))); | |
672 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("bb")) > | |
673 StringPiece16(ASCIIToUTF16("aa"))); | |
674 | |
675 string16 x; | |
676 for (int i = 0; i < 256; i++) { | |
677 x += 'a'; | |
678 string16 y = x; | |
679 ASSERT_EQ(StringPiece16(x), StringPiece16(y)); | |
680 for (int j = 0; j < i; j++) { | |
681 string16 z = x; | |
682 z[j] = 'b'; // Differs in position 'j' | |
683 ASSERT_NE(StringPiece16(x), StringPiece16(z)); | |
684 } | |
685 } | |
686 } | |
687 | |
688 TEST(StringPiece16Test, CheckSTL) { | 634 TEST(StringPiece16Test, CheckSTL) { |
689 string16 first = ASCIIToUTF16("abcdefghijklmnopqrstuvwxyz"); | |
690 StringPiece16 a(first); | |
691 string16 second = ASCIIToUTF16("abc"); | |
692 StringPiece16 b(second.c_str()); | |
693 string16 third = ASCIIToUTF16("xyz"); | |
694 StringPiece16 c(third.c_str(), third.size()); | |
695 string16 fourth = ASCIIToUTF16("foobarrandomstuff"); | |
696 StringPiece16 d(fourth.c_str(), 6); | |
697 StringPiece16 e; | |
698 // Check some non-ascii characters. | 635 // Check some non-ascii characters. |
699 string16 fifth(ASCIIToUTF16("123")); | 636 string16 fifth(ASCIIToUTF16("123")); |
700 fifth.push_back(0x0000); | 637 fifth.push_back(0x0000); |
701 fifth.push_back(0xd8c5); | 638 fifth.push_back(0xd8c5); |
702 fifth.push_back(0xdffe); | 639 fifth.push_back(0xdffe); |
703 StringPiece16 f(fifth); | 640 StringPiece16 f(fifth); |
704 | 641 |
705 ASSERT_EQ(a[6], 'g'); | |
706 ASSERT_EQ(b[0], 'a'); | |
707 ASSERT_EQ(c[2], 'z'); | |
708 ASSERT_EQ(f[3], '\0'); | 642 ASSERT_EQ(f[3], '\0'); |
709 ASSERT_EQ(f[5], static_cast<char16>(0xdffe)); | 643 ASSERT_EQ(f[5], static_cast<char16>(0xdffe)); |
710 | 644 |
711 ASSERT_EQ(*d.data(), 'f'); | |
712 ASSERT_EQ(d.data()[5], 'r'); | |
713 ASSERT_TRUE(e.data() == NULL); | |
714 | |
715 ASSERT_EQ(*a.begin(), 'a'); | |
716 ASSERT_EQ(*(b.begin() + 2), 'c'); | |
717 ASSERT_EQ(*(c.end() - 1), 'z'); | |
718 | |
719 ASSERT_EQ(*a.rbegin(), 'z'); | |
720 ASSERT_EQ(*(b.rbegin() + 2), 'a'); | |
721 ASSERT_EQ(*(c.rend() - 1), 'x'); | |
722 ASSERT_TRUE(a.rbegin() + 26 == a.rend()); | |
723 | |
724 ASSERT_EQ(a.size(), 26U); | |
725 ASSERT_EQ(b.size(), 3U); | |
726 ASSERT_EQ(c.size(), 3U); | |
727 ASSERT_EQ(d.size(), 6U); | |
728 ASSERT_EQ(e.size(), 0U); | |
729 ASSERT_EQ(f.size(), 6U); | 645 ASSERT_EQ(f.size(), 6U); |
730 | |
731 ASSERT_TRUE(!d.empty()); | |
732 ASSERT_TRUE(d.begin() != d.end()); | |
733 ASSERT_TRUE(d.begin() + 6 == d.end()); | |
734 | |
735 ASSERT_TRUE(e.empty()); | |
736 ASSERT_TRUE(e.begin() == e.end()); | |
737 | |
738 d.clear(); | |
739 ASSERT_EQ(d.size(), 0U); | |
740 ASSERT_TRUE(d.empty()); | |
741 ASSERT_TRUE(d.data() == NULL); | |
742 ASSERT_TRUE(d.begin() == d.end()); | |
743 | |
744 ASSERT_GE(a.max_size(), a.capacity()); | |
745 ASSERT_GE(a.capacity(), a.size()); | |
746 } | 646 } |
747 | 647 |
748 TEST(StringPiece16Test, CheckNULL) { | |
749 StringPiece16 s(NULL); | |
750 ASSERT_EQ(s.data(), (const char16*)NULL); | |
751 ASSERT_EQ(s.size(), 0U); | |
752 | 648 |
753 s.set(NULL); | |
754 ASSERT_EQ(s.data(), (const char16*)NULL); | |
755 ASSERT_EQ(s.size(), 0U); | |
756 | |
757 string16 str = s.as_string16(); | |
758 ASSERT_EQ(s.data(), (const char16*)NULL); | |
759 ASSERT_EQ(s.size(), 0U); | |
760 } | |
761 | |
762 TEST(StringPiece16Test, HeterogenousStringPieceEquals) { | |
763 ASSERT_TRUE(StringPiece16(ASCIIToUTF16("hello")) == ASCIIToUTF16("hello")); | |
764 } | |
765 | 649 |
766 TEST(StringPiece16Test, CheckConversion) { | 650 TEST(StringPiece16Test, CheckConversion) { |
767 // Make sure that we can convert from UTF8 to UTF16 and back. We use a two | 651 // Make sure that we can convert from UTF8 to UTF16 and back. We use a two |
768 // byte character (G clef) to test this. | 652 // byte character (G clef) to test this. |
769 ASSERT_EQ( | 653 ASSERT_EQ( |
770 UTF16ToUTF8( | 654 UTF16ToUTF8( |
771 StringPiece16(UTF8ToUTF16("\xf0\x9d\x84\x9e")).as_string16()), | 655 StringPiece16(UTF8ToUTF16("\xf0\x9d\x84\x9e")).as_string()), |
772 "\xf0\x9d\x84\x9e"); | 656 "\xf0\x9d\x84\x9e"); |
773 } | 657 } |
774 | 658 |
| 659 TYPED_TEST(CommonStringPieceTest, CheckConstructors) { |
| 660 TypeParam str(TestFixture::as_string("hello world")); |
| 661 TypeParam empty; |
| 662 |
| 663 ASSERT_TRUE(str == BasicStringPiece<TypeParam>(str)); |
| 664 ASSERT_TRUE(str == BasicStringPiece<TypeParam>(str.c_str())); |
| 665 ASSERT_TRUE(TestFixture::as_string("hello") == |
| 666 BasicStringPiece<TypeParam>(str.c_str(), 5)); |
| 667 ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(str.c_str(), 0)); |
| 668 ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(NULL)); |
| 669 ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(NULL, 0)); |
| 670 ASSERT_TRUE(empty == BasicStringPiece<TypeParam>()); |
| 671 ASSERT_TRUE(str == BasicStringPiece<TypeParam>(str.begin(), str.end())); |
| 672 ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(str.begin(), str.begin())); |
| 673 ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(empty)); |
| 674 ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(empty.begin(), empty.end())); |
| 675 } |
| 676 |
775 } // namespace base | 677 } // namespace base |
OLD | NEW |