string_piece_unittest.cc 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include <stddef.h>
  5. #include <string>
  6. #include "base/strings/string_piece.h"
  7. #include "base/strings/utf_string_conversions.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. namespace base {
  10. template <typename CharT>
  11. class CommonStringPieceTest : public ::testing::Test {
  12. public:
  13. static std::string as_string(const char* input) { return input; }
  14. static const std::string& as_string(const std::string& input) {
  15. return input;
  16. }
  17. };
  18. template <>
  19. class CommonStringPieceTest<char16_t> : public ::testing::Test {
  20. public:
  21. static std::u16string as_string(const char* input) {
  22. return UTF8ToUTF16(input);
  23. }
  24. static std::u16string as_string(const std::string& input) {
  25. return UTF8ToUTF16(input);
  26. }
  27. };
  28. typedef ::testing::Types<char, char16_t> SupportedCharTypes;
  29. TYPED_TEST_SUITE(CommonStringPieceTest, SupportedCharTypes);
  30. TYPED_TEST(CommonStringPieceTest, CheckComparisonOperators) {
  31. #define CMP_Y(op, x, y) \
  32. { \
  33. std::basic_string<TypeParam> lhs(TestFixture::as_string(x)); \
  34. std::basic_string<TypeParam> rhs(TestFixture::as_string(y)); \
  35. ASSERT_TRUE((BasicStringPiece<TypeParam>((lhs.c_str())) \
  36. op BasicStringPiece<TypeParam>((rhs.c_str())))); \
  37. ASSERT_TRUE(BasicStringPiece<TypeParam>(lhs) op rhs); \
  38. ASSERT_TRUE(lhs op BasicStringPiece<TypeParam>(rhs)); \
  39. ASSERT_TRUE((BasicStringPiece<TypeParam>((lhs.c_str())) \
  40. .compare(BasicStringPiece<TypeParam>((rhs.c_str()))) \
  41. op 0)); \
  42. }
  43. #define CMP_N(op, x, y) \
  44. { \
  45. std::basic_string<TypeParam> lhs(TestFixture::as_string(x)); \
  46. std::basic_string<TypeParam> rhs(TestFixture::as_string(y)); \
  47. ASSERT_FALSE((BasicStringPiece<TypeParam>((lhs.c_str())) \
  48. op BasicStringPiece<TypeParam>((rhs.c_str())))); \
  49. ASSERT_FALSE(BasicStringPiece<TypeParam>(lhs) op rhs); \
  50. ASSERT_FALSE(lhs op BasicStringPiece<TypeParam>(rhs)); \
  51. ASSERT_FALSE((BasicStringPiece<TypeParam>((lhs.c_str())) \
  52. .compare(BasicStringPiece<TypeParam>((rhs.c_str()))) \
  53. op 0)); \
  54. }
  55. CMP_Y(==, "", "")
  56. CMP_Y(==, "a", "a")
  57. CMP_Y(==, "aa", "aa")
  58. CMP_N(==, "a", "")
  59. CMP_N(==, "", "a")
  60. CMP_N(==, "a", "b")
  61. CMP_N(==, "a", "aa")
  62. CMP_N(==, "aa", "a")
  63. CMP_N(!=, "", "")
  64. CMP_N(!=, "a", "a")
  65. CMP_N(!=, "aa", "aa")
  66. CMP_Y(!=, "a", "")
  67. CMP_Y(!=, "", "a")
  68. CMP_Y(!=, "a", "b")
  69. CMP_Y(!=, "a", "aa")
  70. CMP_Y(!=, "aa", "a")
  71. CMP_Y(<, "a", "b")
  72. CMP_Y(<, "a", "aa")
  73. CMP_Y(<, "aa", "b")
  74. CMP_Y(<, "aa", "bb")
  75. CMP_N(<, "a", "a")
  76. CMP_N(<, "b", "a")
  77. CMP_N(<, "aa", "a")
  78. CMP_N(<, "b", "aa")
  79. CMP_N(<, "bb", "aa")
  80. CMP_Y(<=, "a", "a")
  81. CMP_Y(<=, "a", "b")
  82. CMP_Y(<=, "a", "aa")
  83. CMP_Y(<=, "aa", "b")
  84. CMP_Y(<=, "aa", "bb")
  85. CMP_N(<=, "b", "a")
  86. CMP_N(<=, "aa", "a")
  87. CMP_N(<=, "b", "aa")
  88. CMP_N(<=, "bb", "aa")
  89. CMP_N(>=, "a", "b")
  90. CMP_N(>=, "a", "aa")
  91. CMP_N(>=, "aa", "b")
  92. CMP_N(>=, "aa", "bb")
  93. CMP_Y(>=, "a", "a")
  94. CMP_Y(>=, "b", "a")
  95. CMP_Y(>=, "aa", "a")
  96. CMP_Y(>=, "b", "aa")
  97. CMP_Y(>=, "bb", "aa")
  98. CMP_N(>, "a", "a")
  99. CMP_N(>, "a", "b")
  100. CMP_N(>, "a", "aa")
  101. CMP_N(>, "aa", "b")
  102. CMP_N(>, "aa", "bb")
  103. CMP_Y(>, "b", "a")
  104. CMP_Y(>, "aa", "a")
  105. CMP_Y(>, "b", "aa")
  106. CMP_Y(>, "bb", "aa")
  107. std::string x;
  108. for (int i = 0; i < 256; i++) {
  109. x += 'a';
  110. std::string y = x;
  111. CMP_Y(==, x, y);
  112. for (int j = 0; j < i; j++) {
  113. std::string z = x;
  114. z[j] = 'b'; // Differs in position 'j'
  115. CMP_N(==, x, z);
  116. }
  117. }
  118. #undef CMP_Y
  119. #undef CMP_N
  120. }
  121. TYPED_TEST(CommonStringPieceTest, CheckSTL) {
  122. std::basic_string<TypeParam> alphabet(
  123. TestFixture::as_string("abcdefghijklmnopqrstuvwxyz"));
  124. std::basic_string<TypeParam> abc(TestFixture::as_string("abc"));
  125. std::basic_string<TypeParam> xyz(TestFixture::as_string("xyz"));
  126. std::basic_string<TypeParam> foobar(TestFixture::as_string("foobar"));
  127. BasicStringPiece<TypeParam> a(alphabet);
  128. BasicStringPiece<TypeParam> b(abc);
  129. BasicStringPiece<TypeParam> c(xyz);
  130. BasicStringPiece<TypeParam> d(foobar);
  131. BasicStringPiece<TypeParam> e;
  132. std::basic_string<TypeParam> temp(TestFixture::as_string("123"));
  133. temp += static_cast<TypeParam>(0);
  134. temp += TestFixture::as_string("456");
  135. BasicStringPiece<TypeParam> f(temp);
  136. ASSERT_EQ(a[6], static_cast<TypeParam>('g'));
  137. ASSERT_EQ(b[0], static_cast<TypeParam>('a'));
  138. ASSERT_EQ(c[2], static_cast<TypeParam>('z'));
  139. ASSERT_EQ(f[3], static_cast<TypeParam>('\0'));
  140. ASSERT_EQ(f[5], static_cast<TypeParam>('5'));
  141. ASSERT_EQ(*d.data(), static_cast<TypeParam>('f'));
  142. ASSERT_EQ(d.data()[5], static_cast<TypeParam>('r'));
  143. ASSERT_EQ(e.data(), nullptr);
  144. ASSERT_EQ(*a.begin(), static_cast<TypeParam>('a'));
  145. ASSERT_EQ(*(b.begin() + 2), static_cast<TypeParam>('c'));
  146. ASSERT_EQ(*(c.end() - 1), static_cast<TypeParam>('z'));
  147. ASSERT_EQ(*a.rbegin(), static_cast<TypeParam>('z'));
  148. ASSERT_EQ(*(b.rbegin() + 2), static_cast<TypeParam>('a'));
  149. ASSERT_EQ(*(c.rend() - 1), static_cast<TypeParam>('x'));
  150. ASSERT_EQ(a.rbegin() + 26, a.rend());
  151. ASSERT_EQ(a.size(), 26U);
  152. ASSERT_EQ(b.size(), 3U);
  153. ASSERT_EQ(c.size(), 3U);
  154. ASSERT_EQ(d.size(), 6U);
  155. ASSERT_EQ(e.size(), 0U);
  156. ASSERT_EQ(f.size(), 7U);
  157. ASSERT_TRUE(!d.empty());
  158. ASSERT_TRUE(d.begin() != d.end());
  159. ASSERT_EQ(d.begin() + 6, d.end());
  160. ASSERT_TRUE(e.empty());
  161. ASSERT_EQ(e.begin(), e.end());
  162. d = BasicStringPiece<TypeParam>();
  163. ASSERT_EQ(d.size(), 0U);
  164. ASSERT_TRUE(d.empty());
  165. ASSERT_EQ(d.data(), nullptr);
  166. ASSERT_EQ(d.begin(), d.end());
  167. ASSERT_GE(a.max_size(), a.size());
  168. }
  169. TYPED_TEST(CommonStringPieceTest, CheckFind) {
  170. typedef BasicStringPiece<TypeParam> Piece;
  171. std::basic_string<TypeParam> alphabet(
  172. TestFixture::as_string("abcdefghijklmnopqrstuvwxyz"));
  173. std::basic_string<TypeParam> abc(TestFixture::as_string("abc"));
  174. std::basic_string<TypeParam> xyz(TestFixture::as_string("xyz"));
  175. std::basic_string<TypeParam> foobar(TestFixture::as_string("foobar"));
  176. BasicStringPiece<TypeParam> a(alphabet);
  177. BasicStringPiece<TypeParam> b(abc);
  178. BasicStringPiece<TypeParam> c(xyz);
  179. BasicStringPiece<TypeParam> d(foobar);
  180. d = Piece();
  181. Piece e;
  182. std::basic_string<TypeParam> temp(TestFixture::as_string("123"));
  183. temp.push_back('\0');
  184. temp += TestFixture::as_string("456");
  185. Piece f(temp);
  186. TypeParam buf[4] = {'%', '%', '%', '%'};
  187. ASSERT_EQ(a.copy(buf, 4), 4U);
  188. ASSERT_EQ(buf[0], a[0]);
  189. ASSERT_EQ(buf[1], a[1]);
  190. ASSERT_EQ(buf[2], a[2]);
  191. ASSERT_EQ(buf[3], a[3]);
  192. ASSERT_EQ(a.copy(buf, 3, 7), 3U);
  193. ASSERT_EQ(buf[0], a[7]);
  194. ASSERT_EQ(buf[1], a[8]);
  195. ASSERT_EQ(buf[2], a[9]);
  196. ASSERT_EQ(buf[3], a[3]);
  197. ASSERT_EQ(c.copy(buf, 99), 3U);
  198. ASSERT_EQ(buf[0], c[0]);
  199. ASSERT_EQ(buf[1], c[1]);
  200. ASSERT_EQ(buf[2], c[2]);
  201. ASSERT_EQ(buf[3], a[3]);
  202. ASSERT_EQ(Piece::npos, std::basic_string<TypeParam>::npos);
  203. ASSERT_EQ(a.find(b), 0U);
  204. ASSERT_EQ(a.find(b, 1), Piece::npos);
  205. ASSERT_EQ(a.find(c), 23U);
  206. ASSERT_EQ(a.find(c, 9), 23U);
  207. ASSERT_EQ(a.find(c, Piece::npos), Piece::npos);
  208. ASSERT_EQ(b.find(c), Piece::npos);
  209. ASSERT_EQ(b.find(c, Piece::npos), Piece::npos);
  210. ASSERT_EQ(a.find(d), 0U);
  211. ASSERT_EQ(a.find(e), 0U);
  212. ASSERT_EQ(a.find(d, 12), 12U);
  213. ASSERT_EQ(a.find(e, 17), 17U);
  214. std::basic_string<TypeParam> not_found(
  215. TestFixture::as_string("xx not found bb"));
  216. Piece g(not_found);
  217. ASSERT_EQ(a.find(g), Piece::npos);
  218. // empty string nonsense
  219. ASSERT_EQ(d.find(b), Piece::npos);
  220. ASSERT_EQ(e.find(b), Piece::npos);
  221. ASSERT_EQ(d.find(b, 4), Piece::npos);
  222. ASSERT_EQ(e.find(b, 7), Piece::npos);
  223. size_t empty_search_pos =
  224. std::basic_string<TypeParam>().find(std::basic_string<TypeParam>());
  225. ASSERT_EQ(d.find(d), empty_search_pos);
  226. ASSERT_EQ(d.find(e), empty_search_pos);
  227. ASSERT_EQ(e.find(d), empty_search_pos);
  228. ASSERT_EQ(e.find(e), empty_search_pos);
  229. ASSERT_EQ(d.find(d, 4), std::string().find(std::string(), 4));
  230. ASSERT_EQ(d.find(e, 4), std::string().find(std::string(), 4));
  231. ASSERT_EQ(e.find(d, 4), std::string().find(std::string(), 4));
  232. ASSERT_EQ(e.find(e, 4), std::string().find(std::string(), 4));
  233. constexpr TypeParam kNul = '\0';
  234. ASSERT_EQ(a.find('a'), 0U);
  235. ASSERT_EQ(a.find('c'), 2U);
  236. ASSERT_EQ(a.find('z'), 25U);
  237. ASSERT_EQ(a.find('$'), Piece::npos);
  238. ASSERT_EQ(a.find(kNul), Piece::npos);
  239. ASSERT_EQ(f.find(kNul), 3U);
  240. ASSERT_EQ(f.find('3'), 2U);
  241. ASSERT_EQ(f.find('5'), 5U);
  242. ASSERT_EQ(g.find('o'), 4U);
  243. ASSERT_EQ(g.find('o', 4), 4U);
  244. ASSERT_EQ(g.find('o', 5), 8U);
  245. ASSERT_EQ(a.find('b', 5), Piece::npos);
  246. // empty string nonsense
  247. ASSERT_EQ(d.find(kNul), Piece::npos);
  248. ASSERT_EQ(e.find(kNul), Piece::npos);
  249. ASSERT_EQ(d.find(kNul, 4), Piece::npos);
  250. ASSERT_EQ(e.find(kNul, 7), Piece::npos);
  251. ASSERT_EQ(d.find('x'), Piece::npos);
  252. ASSERT_EQ(e.find('x'), Piece::npos);
  253. ASSERT_EQ(d.find('x', 4), Piece::npos);
  254. ASSERT_EQ(e.find('x', 7), Piece::npos);
  255. ASSERT_EQ(a.find(b.data(), 1, 0), 1U);
  256. ASSERT_EQ(a.find(c.data(), 9, 0), 9U);
  257. ASSERT_EQ(a.find(c.data(), Piece::npos, 0), Piece::npos);
  258. ASSERT_EQ(b.find(c.data(), Piece::npos, 0), Piece::npos);
  259. // empty string nonsense
  260. ASSERT_EQ(d.find(b.data(), 4, 0), Piece::npos);
  261. ASSERT_EQ(e.find(b.data(), 7, 0), Piece::npos);
  262. ASSERT_EQ(a.find(b.data(), 1), Piece::npos);
  263. ASSERT_EQ(a.find(c.data(), 9), 23U);
  264. ASSERT_EQ(a.find(c.data(), Piece::npos), Piece::npos);
  265. ASSERT_EQ(b.find(c.data(), Piece::npos), Piece::npos);
  266. // empty string nonsense
  267. ASSERT_EQ(d.find(b.data(), 4), Piece::npos);
  268. ASSERT_EQ(e.find(b.data(), 7), Piece::npos);
  269. ASSERT_EQ(a.rfind(b), 0U);
  270. ASSERT_EQ(a.rfind(b, 1), 0U);
  271. ASSERT_EQ(a.rfind(c), 23U);
  272. ASSERT_EQ(a.rfind(c, 22U), Piece::npos);
  273. ASSERT_EQ(a.rfind(c, 1U), Piece::npos);
  274. ASSERT_EQ(a.rfind(c, 0U), Piece::npos);
  275. ASSERT_EQ(b.rfind(c), Piece::npos);
  276. ASSERT_EQ(b.rfind(c, 0U), Piece::npos);
  277. ASSERT_EQ(a.rfind(d),
  278. static_cast<size_t>(a.rfind(std::basic_string<TypeParam>())));
  279. ASSERT_EQ(a.rfind(e), a.rfind(std::basic_string<TypeParam>()));
  280. ASSERT_EQ(a.rfind(d),
  281. static_cast<size_t>(std::basic_string<TypeParam>(a).rfind(
  282. std::basic_string<TypeParam>())));
  283. ASSERT_EQ(a.rfind(e), std::basic_string<TypeParam>(a).rfind(
  284. std::basic_string<TypeParam>()));
  285. ASSERT_EQ(a.rfind(d, 12), 12U);
  286. ASSERT_EQ(a.rfind(e, 17), 17U);
  287. ASSERT_EQ(a.rfind(g), Piece::npos);
  288. ASSERT_EQ(d.rfind(b), Piece::npos);
  289. ASSERT_EQ(e.rfind(b), Piece::npos);
  290. ASSERT_EQ(d.rfind(b, 4), Piece::npos);
  291. ASSERT_EQ(e.rfind(b, 7), Piece::npos);
  292. // empty string nonsense
  293. ASSERT_EQ(d.rfind(d, 4), std::string().rfind(std::string()));
  294. ASSERT_EQ(e.rfind(d, 7), std::string().rfind(std::string()));
  295. ASSERT_EQ(d.rfind(e, 4), std::string().rfind(std::string()));
  296. ASSERT_EQ(e.rfind(e, 7), std::string().rfind(std::string()));
  297. ASSERT_EQ(d.rfind(d), std::string().rfind(std::string()));
  298. ASSERT_EQ(e.rfind(d), std::string().rfind(std::string()));
  299. ASSERT_EQ(d.rfind(e), std::string().rfind(std::string()));
  300. ASSERT_EQ(e.rfind(e), std::string().rfind(std::string()));
  301. ASSERT_EQ(g.rfind('o'), 8U);
  302. ASSERT_EQ(g.rfind('q'), Piece::npos);
  303. ASSERT_EQ(g.rfind('o', 8), 8U);
  304. ASSERT_EQ(g.rfind('o', 7), 4U);
  305. ASSERT_EQ(g.rfind('o', 3), Piece::npos);
  306. ASSERT_EQ(f.rfind(kNul), 3U);
  307. ASSERT_EQ(f.rfind(kNul, 12), 3U);
  308. ASSERT_EQ(f.rfind('3'), 2U);
  309. ASSERT_EQ(f.rfind('5'), 5U);
  310. // empty string nonsense
  311. ASSERT_EQ(d.rfind('o'), Piece::npos);
  312. ASSERT_EQ(e.rfind('o'), Piece::npos);
  313. ASSERT_EQ(d.rfind('o', 4), Piece::npos);
  314. ASSERT_EQ(e.rfind('o', 7), Piece::npos);
  315. ASSERT_EQ(a.rfind(b.data(), 1, 0), 1U);
  316. ASSERT_EQ(a.rfind(c.data(), 22U, 0), 22U);
  317. ASSERT_EQ(a.rfind(c.data(), 1U, 0), 1U);
  318. ASSERT_EQ(a.rfind(c.data(), 0U, 0), 0U);
  319. ASSERT_EQ(b.rfind(c.data(), 0U, 0), 0U);
  320. ASSERT_EQ(d.rfind(b.data(), 4, 0), 0U);
  321. ASSERT_EQ(e.rfind(b.data(), 7, 0), 0U);
  322. std::basic_string<TypeParam> one_two_three_four(
  323. TestFixture::as_string("one,two:three;four"));
  324. std::basic_string<TypeParam> comma_colon(TestFixture::as_string(",:"));
  325. ASSERT_EQ(3U, Piece(one_two_three_four).find_first_of(comma_colon));
  326. ASSERT_EQ(a.find_first_of(b), 0U);
  327. ASSERT_EQ(a.find_first_of(b, 0), 0U);
  328. ASSERT_EQ(a.find_first_of(b, 1), 1U);
  329. ASSERT_EQ(a.find_first_of(b, 2), 2U);
  330. ASSERT_EQ(a.find_first_of(b, 3), Piece::npos);
  331. ASSERT_EQ(a.find_first_of(c), 23U);
  332. ASSERT_EQ(a.find_first_of(c, 23), 23U);
  333. ASSERT_EQ(a.find_first_of(c, 24), 24U);
  334. ASSERT_EQ(a.find_first_of(c, 25), 25U);
  335. ASSERT_EQ(a.find_first_of(c, 26), Piece::npos);
  336. ASSERT_EQ(g.find_first_of(b), 13U);
  337. ASSERT_EQ(g.find_first_of(c), 0U);
  338. ASSERT_EQ(a.find_first_of(f), Piece::npos);
  339. ASSERT_EQ(f.find_first_of(a), Piece::npos);
  340. // empty string nonsense
  341. ASSERT_EQ(a.find_first_of(d), Piece::npos);
  342. ASSERT_EQ(a.find_first_of(e), Piece::npos);
  343. ASSERT_EQ(d.find_first_of(b), Piece::npos);
  344. ASSERT_EQ(e.find_first_of(b), Piece::npos);
  345. ASSERT_EQ(d.find_first_of(d), Piece::npos);
  346. ASSERT_EQ(e.find_first_of(d), Piece::npos);
  347. ASSERT_EQ(d.find_first_of(e), Piece::npos);
  348. ASSERT_EQ(e.find_first_of(e), Piece::npos);
  349. ASSERT_EQ(a.find_first_not_of(b), 3U);
  350. ASSERT_EQ(a.find_first_not_of(c), 0U);
  351. ASSERT_EQ(b.find_first_not_of(a), Piece::npos);
  352. ASSERT_EQ(c.find_first_not_of(a), Piece::npos);
  353. ASSERT_EQ(f.find_first_not_of(a), 0U);
  354. ASSERT_EQ(a.find_first_not_of(f), 0U);
  355. ASSERT_EQ(a.find_first_not_of(d), 0U);
  356. ASSERT_EQ(a.find_first_not_of(e), 0U);
  357. ASSERT_EQ(a.find_first_not_of(d, 1), 1U);
  358. ASSERT_EQ(a.find_first_not_of(e, 1), 1U);
  359. ASSERT_EQ(a.find_first_not_of(d, a.size()), Piece::npos);
  360. ASSERT_EQ(a.find_first_not_of(e, a.size()), Piece::npos);
  361. // empty string nonsense
  362. ASSERT_EQ(d.find_first_not_of(a), Piece::npos);
  363. ASSERT_EQ(e.find_first_not_of(a), Piece::npos);
  364. ASSERT_EQ(d.find_first_not_of(d), Piece::npos);
  365. ASSERT_EQ(e.find_first_not_of(d), Piece::npos);
  366. ASSERT_EQ(d.find_first_not_of(e), Piece::npos);
  367. ASSERT_EQ(e.find_first_not_of(e), Piece::npos);
  368. std::basic_string<TypeParam> equals(TestFixture::as_string("===="));
  369. Piece h(equals);
  370. ASSERT_EQ(h.find_first_not_of('='), Piece::npos);
  371. ASSERT_EQ(h.find_first_not_of('=', 3), Piece::npos);
  372. ASSERT_EQ(h.find_first_not_of(kNul), 0U);
  373. ASSERT_EQ(g.find_first_not_of('x'), 2U);
  374. ASSERT_EQ(f.find_first_not_of(kNul), 0U);
  375. ASSERT_EQ(f.find_first_not_of(kNul, 3), 4U);
  376. ASSERT_EQ(f.find_first_not_of(kNul, 2), 2U);
  377. // empty string nonsense
  378. ASSERT_EQ(d.find_first_not_of('x'), Piece::npos);
  379. ASSERT_EQ(e.find_first_not_of('x'), Piece::npos);
  380. ASSERT_EQ(d.find_first_not_of(kNul), Piece::npos);
  381. ASSERT_EQ(e.find_first_not_of(kNul), Piece::npos);
  382. // Piece g("xx not found bb");
  383. std::basic_string<TypeParam> fifty_six(TestFixture::as_string("56"));
  384. Piece i(fifty_six);
  385. ASSERT_EQ(h.find_last_of(a), Piece::npos);
  386. ASSERT_EQ(g.find_last_of(a), g.size()-1);
  387. ASSERT_EQ(a.find_last_of(b), 2U);
  388. ASSERT_EQ(a.find_last_of(c), a.size()-1);
  389. ASSERT_EQ(f.find_last_of(i), 6U);
  390. ASSERT_EQ(a.find_last_of('a'), 0U);
  391. ASSERT_EQ(a.find_last_of('b'), 1U);
  392. ASSERT_EQ(a.find_last_of('z'), 25U);
  393. ASSERT_EQ(a.find_last_of('a', 5), 0U);
  394. ASSERT_EQ(a.find_last_of('b', 5), 1U);
  395. ASSERT_EQ(a.find_last_of('b', 0), Piece::npos);
  396. ASSERT_EQ(a.find_last_of('z', 25), 25U);
  397. ASSERT_EQ(a.find_last_of('z', 24), Piece::npos);
  398. ASSERT_EQ(f.find_last_of(i, 5), 5U);
  399. ASSERT_EQ(f.find_last_of(i, 6), 6U);
  400. ASSERT_EQ(f.find_last_of(a, 4), Piece::npos);
  401. // empty string nonsense
  402. ASSERT_EQ(f.find_last_of(d), Piece::npos);
  403. ASSERT_EQ(f.find_last_of(e), Piece::npos);
  404. ASSERT_EQ(f.find_last_of(d, 4), Piece::npos);
  405. ASSERT_EQ(f.find_last_of(e, 4), Piece::npos);
  406. ASSERT_EQ(d.find_last_of(d), Piece::npos);
  407. ASSERT_EQ(d.find_last_of(e), Piece::npos);
  408. ASSERT_EQ(e.find_last_of(d), Piece::npos);
  409. ASSERT_EQ(e.find_last_of(e), Piece::npos);
  410. ASSERT_EQ(d.find_last_of(f), Piece::npos);
  411. ASSERT_EQ(e.find_last_of(f), Piece::npos);
  412. ASSERT_EQ(d.find_last_of(d, 4), Piece::npos);
  413. ASSERT_EQ(d.find_last_of(e, 4), Piece::npos);
  414. ASSERT_EQ(e.find_last_of(d, 4), Piece::npos);
  415. ASSERT_EQ(e.find_last_of(e, 4), Piece::npos);
  416. ASSERT_EQ(d.find_last_of(f, 4), Piece::npos);
  417. ASSERT_EQ(e.find_last_of(f, 4), Piece::npos);
  418. ASSERT_EQ(a.find_last_not_of(b), a.size()-1);
  419. ASSERT_EQ(a.find_last_not_of(c), 22U);
  420. ASSERT_EQ(b.find_last_not_of(a), Piece::npos);
  421. ASSERT_EQ(b.find_last_not_of(b), Piece::npos);
  422. ASSERT_EQ(f.find_last_not_of(i), 4U);
  423. ASSERT_EQ(a.find_last_not_of(c, 24), 22U);
  424. ASSERT_EQ(a.find_last_not_of(b, 3), 3U);
  425. ASSERT_EQ(a.find_last_not_of(b, 2), Piece::npos);
  426. // empty string nonsense
  427. ASSERT_EQ(f.find_last_not_of(d), f.size()-1);
  428. ASSERT_EQ(f.find_last_not_of(e), f.size()-1);
  429. ASSERT_EQ(f.find_last_not_of(d, 4), 4U);
  430. ASSERT_EQ(f.find_last_not_of(e, 4), 4U);
  431. ASSERT_EQ(d.find_last_not_of(d), Piece::npos);
  432. ASSERT_EQ(d.find_last_not_of(e), Piece::npos);
  433. ASSERT_EQ(e.find_last_not_of(d), Piece::npos);
  434. ASSERT_EQ(e.find_last_not_of(e), Piece::npos);
  435. ASSERT_EQ(d.find_last_not_of(f), Piece::npos);
  436. ASSERT_EQ(e.find_last_not_of(f), Piece::npos);
  437. ASSERT_EQ(d.find_last_not_of(d, 4), Piece::npos);
  438. ASSERT_EQ(d.find_last_not_of(e, 4), Piece::npos);
  439. ASSERT_EQ(e.find_last_not_of(d, 4), Piece::npos);
  440. ASSERT_EQ(e.find_last_not_of(e, 4), Piece::npos);
  441. ASSERT_EQ(d.find_last_not_of(f, 4), Piece::npos);
  442. ASSERT_EQ(e.find_last_not_of(f, 4), Piece::npos);
  443. ASSERT_EQ(h.find_last_not_of('x'), h.size() - 1);
  444. ASSERT_EQ(h.find_last_not_of('='), Piece::npos);
  445. ASSERT_EQ(b.find_last_not_of('c'), 1U);
  446. ASSERT_EQ(h.find_last_not_of('x', 2), 2U);
  447. ASSERT_EQ(h.find_last_not_of('=', 2), Piece::npos);
  448. ASSERT_EQ(b.find_last_not_of('b', 1), 0U);
  449. // empty string nonsense
  450. ASSERT_EQ(d.find_last_not_of('x'), Piece::npos);
  451. ASSERT_EQ(e.find_last_not_of('x'), Piece::npos);
  452. ASSERT_EQ(d.find_last_not_of(kNul), Piece::npos);
  453. ASSERT_EQ(e.find_last_not_of(kNul), Piece::npos);
  454. ASSERT_EQ(a.substr(0, 3), b);
  455. ASSERT_EQ(a.substr(23), c);
  456. ASSERT_EQ(a.substr(23, 3), c);
  457. ASSERT_EQ(a.substr(23, 99), c);
  458. ASSERT_EQ(a.substr(), a);
  459. ASSERT_EQ(a.substr(0), a);
  460. ASSERT_EQ(a.substr(3, 2), TestFixture::as_string("de"));
  461. ASSERT_EQ(d.substr(0, 99), e);
  462. }
  463. TYPED_TEST(CommonStringPieceTest, CheckCustom) {
  464. std::basic_string<TypeParam> foobar(TestFixture::as_string("foobar"));
  465. BasicStringPiece<TypeParam> a(foobar);
  466. std::basic_string<TypeParam> s1(TestFixture::as_string("123"));
  467. s1 += static_cast<TypeParam>('\0');
  468. s1 += TestFixture::as_string("456");
  469. BasicStringPiece<TypeParam> b(s1);
  470. BasicStringPiece<TypeParam> e;
  471. std::basic_string<TypeParam> s2;
  472. // remove_prefix
  473. BasicStringPiece<TypeParam> c(a);
  474. c.remove_prefix(3);
  475. ASSERT_EQ(c, TestFixture::as_string("bar"));
  476. c = a;
  477. c.remove_prefix(0);
  478. ASSERT_EQ(c, a);
  479. c.remove_prefix(c.size());
  480. ASSERT_EQ(c, e);
  481. // remove_suffix
  482. c = a;
  483. c.remove_suffix(3);
  484. ASSERT_EQ(c, TestFixture::as_string("foo"));
  485. c = a;
  486. c.remove_suffix(0);
  487. ASSERT_EQ(c, a);
  488. c.remove_suffix(c.size());
  489. ASSERT_EQ(c, e);
  490. // assignment
  491. c = foobar.c_str();
  492. ASSERT_EQ(c, a);
  493. c = {foobar.c_str(), 6};
  494. ASSERT_EQ(c, a);
  495. c = {foobar.c_str(), 0};
  496. ASSERT_EQ(c, e);
  497. c = {foobar.c_str(), 7}; // Note, has an embedded NULL
  498. ASSERT_NE(c, a);
  499. // operator STRING_TYPE()
  500. std::basic_string<TypeParam> s5(std::basic_string<TypeParam>(a).c_str(),
  501. 7); // Note, has an embedded NULL
  502. ASSERT_EQ(c, s5);
  503. std::basic_string<TypeParam> s6(e);
  504. ASSERT_TRUE(s6.empty());
  505. }
  506. TEST(StringPieceTest, CheckCustom) {
  507. StringPiece a("foobar");
  508. std::string s1("123");
  509. s1 += '\0';
  510. s1 += "456";
  511. StringPiece b(s1);
  512. StringPiece e;
  513. std::string s2;
  514. StringPiece c;
  515. c = {"foobar", 6};
  516. ASSERT_EQ(c, a);
  517. c = {"foobar", 0};
  518. ASSERT_EQ(c, e);
  519. c = {"foobar", 7};
  520. ASSERT_NE(c, a);
  521. }
  522. TYPED_TEST(CommonStringPieceTest, CheckNULL) {
  523. BasicStringPiece<TypeParam> s;
  524. ASSERT_EQ(s.data(), nullptr);
  525. ASSERT_EQ(s.size(), 0U);
  526. std::basic_string<TypeParam> str(s);
  527. ASSERT_EQ(str.length(), 0U);
  528. ASSERT_EQ(str, std::basic_string<TypeParam>());
  529. }
  530. TYPED_TEST(CommonStringPieceTest, CheckComparisons2) {
  531. std::basic_string<TypeParam> alphabet(
  532. TestFixture::as_string("abcdefghijklmnopqrstuvwxyz"));
  533. std::basic_string<TypeParam> alphabet_z(
  534. TestFixture::as_string("abcdefghijklmnopqrstuvwxyzz"));
  535. std::basic_string<TypeParam> alphabet_y(
  536. TestFixture::as_string("abcdefghijklmnopqrstuvwxyy"));
  537. BasicStringPiece<TypeParam> abc(alphabet);
  538. // check comparison operations on strings longer than 4 bytes.
  539. ASSERT_EQ(abc, BasicStringPiece<TypeParam>(alphabet));
  540. ASSERT_EQ(abc.compare(BasicStringPiece<TypeParam>(alphabet)), 0);
  541. ASSERT_TRUE(abc < BasicStringPiece<TypeParam>(alphabet_z));
  542. ASSERT_LT(abc.compare(BasicStringPiece<TypeParam>(alphabet_z)), 0);
  543. ASSERT_TRUE(abc > BasicStringPiece<TypeParam>(alphabet_y));
  544. ASSERT_GT(abc.compare(BasicStringPiece<TypeParam>(alphabet_y)), 0);
  545. }
  546. TYPED_TEST(CommonStringPieceTest, StringCompareNotAmbiguous) {
  547. ASSERT_TRUE(TestFixture::as_string("hello").c_str() ==
  548. TestFixture::as_string("hello"));
  549. ASSERT_TRUE(TestFixture::as_string("hello").c_str() <
  550. TestFixture::as_string("world"));
  551. }
  552. TYPED_TEST(CommonStringPieceTest, HeterogenousStringPieceEquals) {
  553. std::basic_string<TypeParam> hello(TestFixture::as_string("hello"));
  554. ASSERT_EQ(BasicStringPiece<TypeParam>(hello), hello);
  555. ASSERT_EQ(hello.c_str(), BasicStringPiece<TypeParam>(hello));
  556. }
  557. // std::u16string-specific stuff
  558. TEST(StringPiece16Test, CheckSTL) {
  559. // Check some non-ascii characters.
  560. std::u16string fifth(u"123");
  561. fifth.push_back(0x0000);
  562. fifth.push_back(0xd8c5);
  563. fifth.push_back(0xdffe);
  564. StringPiece16 f(fifth);
  565. ASSERT_EQ(f[3], '\0');
  566. ASSERT_EQ(f[5], 0xdffe);
  567. ASSERT_EQ(f.size(), 6U);
  568. }
  569. TEST(StringPiece16Test, CheckConversion) {
  570. // Make sure that we can convert from UTF8 to UTF16 and back. We use a
  571. // character (G clef) outside the BMP to test this.
  572. const char* kTest = "\U0001D11E";
  573. ASSERT_EQ(UTF16ToUTF8(UTF8ToUTF16(kTest)), kTest);
  574. }
  575. TYPED_TEST(CommonStringPieceTest, CheckConstructors) {
  576. std::basic_string<TypeParam> str(TestFixture::as_string("hello world"));
  577. std::basic_string<TypeParam> empty;
  578. ASSERT_EQ(str, BasicStringPiece<TypeParam>(str));
  579. ASSERT_EQ(str, BasicStringPiece<TypeParam>(str.c_str()));
  580. ASSERT_TRUE(TestFixture::as_string("hello") ==
  581. BasicStringPiece<TypeParam>(str.c_str(), 5));
  582. ASSERT_EQ(
  583. empty,
  584. BasicStringPiece<TypeParam>(
  585. str.c_str(),
  586. static_cast<typename BasicStringPiece<TypeParam>::size_type>(0)));
  587. ASSERT_EQ(empty, BasicStringPiece<TypeParam>());
  588. ASSERT_TRUE(
  589. empty ==
  590. BasicStringPiece<TypeParam>(
  591. nullptr,
  592. static_cast<typename BasicStringPiece<TypeParam>::size_type>(0)));
  593. ASSERT_EQ(empty, BasicStringPiece<TypeParam>());
  594. ASSERT_EQ(empty, BasicStringPiece<TypeParam>(empty));
  595. }
  596. TEST(StringPieceTest, ConstexprCtor) {
  597. {
  598. constexpr StringPiece piece;
  599. std::ignore = piece;
  600. }
  601. {
  602. constexpr StringPiece piece("abc");
  603. std::ignore = piece;
  604. }
  605. {
  606. constexpr StringPiece piece("abc", 2);
  607. std::ignore = piece;
  608. }
  609. }
  610. TEST(StringPieceTest, OutOfBoundsDeath) {
  611. {
  612. constexpr StringPiece piece;
  613. ASSERT_DEATH_IF_SUPPORTED(piece[0], "");
  614. }
  615. {
  616. constexpr StringPiece piece;
  617. ASSERT_DEATH_IF_SUPPORTED(piece.front(), "");
  618. }
  619. {
  620. constexpr StringPiece piece;
  621. ASSERT_DEATH_IF_SUPPORTED(piece.back(), "");
  622. }
  623. {
  624. StringPiece piece;
  625. ASSERT_DEATH_IF_SUPPORTED(piece.remove_suffix(1), "");
  626. }
  627. {
  628. StringPiece piece;
  629. ASSERT_DEATH_IF_SUPPORTED(piece.remove_prefix(1), "");
  630. }
  631. {
  632. StringPiece piece;
  633. ASSERT_DEATH_IF_SUPPORTED(piece.copy(nullptr, 0, 1), "");
  634. }
  635. {
  636. StringPiece piece;
  637. ASSERT_DEATH_IF_SUPPORTED(piece.substr(1), "");
  638. }
  639. }
  640. TEST(StringPieceTest, ConstexprData) {
  641. {
  642. constexpr StringPiece piece;
  643. static_assert(piece.data() == nullptr, "");
  644. }
  645. {
  646. constexpr StringPiece piece("abc");
  647. static_assert(piece.data()[0] == 'a', "");
  648. static_assert(piece.data()[1] == 'b', "");
  649. static_assert(piece.data()[2] == 'c', "");
  650. }
  651. {
  652. constexpr StringPiece piece("def", 2);
  653. static_assert(piece.data()[0] == 'd', "");
  654. static_assert(piece.data()[1] == 'e', "");
  655. }
  656. }
  657. TEST(StringPieceTest, ConstexprSize) {
  658. {
  659. constexpr StringPiece piece;
  660. static_assert(piece.size() == 0, "");
  661. }
  662. {
  663. constexpr StringPiece piece("abc");
  664. static_assert(piece.size() == 3, "");
  665. }
  666. {
  667. constexpr StringPiece piece("def", 2);
  668. static_assert(piece.size() == 2, "");
  669. }
  670. }
  671. TEST(StringPieceTest, ConstexprFront) {
  672. static_assert(StringPiece("abc").front() == 'a', "");
  673. }
  674. TEST(StringPieceTest, ConstexprBack) {
  675. static_assert(StringPiece("abc").back() == 'c', "");
  676. }
  677. TEST(StringPieceTest, Compare) {
  678. constexpr StringPiece piece = "def";
  679. static_assert(piece.compare("ab") == 1, "");
  680. static_assert(piece.compare("abc") == 1, "");
  681. static_assert(piece.compare("abcd") == 1, "");
  682. static_assert(piece.compare("de") == 1, "");
  683. static_assert(piece.compare("def") == 0, "");
  684. static_assert(piece.compare("defg") == -1, "");
  685. static_assert(piece.compare("gh") == -1, "");
  686. static_assert(piece.compare("ghi") == -1, "");
  687. static_assert(piece.compare("ghij") == -1, "");
  688. static_assert(piece.compare(0, 0, "") == 0, "");
  689. static_assert(piece.compare(0, 1, "d") == 0, "");
  690. static_assert(piece.compare(0, 2, "de") == 0, "");
  691. static_assert(piece.compare(0, 3, "def") == 0, "");
  692. static_assert(piece.compare(1, 0, "") == 0, "");
  693. static_assert(piece.compare(1, 1, "e") == 0, "");
  694. static_assert(piece.compare(1, 2, "ef") == 0, "");
  695. static_assert(piece.compare(1, 3, "ef") == 0, "");
  696. static_assert(piece.compare(2, 0, "") == 0, "");
  697. static_assert(piece.compare(2, 1, "f") == 0, "");
  698. static_assert(piece.compare(2, 2, "f") == 0, "");
  699. static_assert(piece.compare(2, 3, "f") == 0, "");
  700. static_assert(piece.compare(3, 0, "") == 0, "");
  701. static_assert(piece.compare(3, 1, "") == 0, "");
  702. static_assert(piece.compare(3, 2, "") == 0, "");
  703. static_assert(piece.compare(3, 3, "") == 0, "");
  704. static_assert(piece.compare(0, 0, "def", 0) == 0, "");
  705. static_assert(piece.compare(0, 1, "def", 1) == 0, "");
  706. static_assert(piece.compare(0, 2, "def", 2) == 0, "");
  707. static_assert(piece.compare(0, 3, "def", 3) == 0, "");
  708. static_assert(piece.compare(1, 0, "ef", 0) == 0, "");
  709. static_assert(piece.compare(1, 1, "ef", 1) == 0, "");
  710. static_assert(piece.compare(1, 2, "ef", 2) == 0, "");
  711. static_assert(piece.compare(1, 3, "ef", 2) == 0, "");
  712. static_assert(piece.compare(2, 0, "f", 0) == 0, "");
  713. static_assert(piece.compare(2, 1, "f", 1) == 0, "");
  714. static_assert(piece.compare(2, 2, "f", 1) == 0, "");
  715. static_assert(piece.compare(2, 3, "f", 1) == 0, "");
  716. static_assert(piece.compare(3, 0, "", 0) == 0, "");
  717. static_assert(piece.compare(3, 1, "", 0) == 0, "");
  718. static_assert(piece.compare(3, 2, "", 0) == 0, "");
  719. static_assert(piece.compare(3, 3, "", 0) == 0, "");
  720. static_assert(piece.compare(0, 0, "def", 0, 0) == 0, "");
  721. static_assert(piece.compare(0, 1, "def", 0, 1) == 0, "");
  722. static_assert(piece.compare(0, 2, "def", 0, 2) == 0, "");
  723. static_assert(piece.compare(0, 3, "def", 0, 3) == 0, "");
  724. static_assert(piece.compare(1, 0, "def", 1, 0) == 0, "");
  725. static_assert(piece.compare(1, 1, "def", 1, 1) == 0, "");
  726. static_assert(piece.compare(1, 2, "def", 1, 2) == 0, "");
  727. static_assert(piece.compare(1, 3, "def", 1, 3) == 0, "");
  728. static_assert(piece.compare(2, 0, "def", 2, 0) == 0, "");
  729. static_assert(piece.compare(2, 1, "def", 2, 1) == 0, "");
  730. static_assert(piece.compare(2, 2, "def", 2, 2) == 0, "");
  731. static_assert(piece.compare(2, 3, "def", 2, 3) == 0, "");
  732. static_assert(piece.compare(3, 0, "def", 3, 0) == 0, "");
  733. static_assert(piece.compare(3, 1, "def", 3, 1) == 0, "");
  734. static_assert(piece.compare(3, 2, "def", 3, 2) == 0, "");
  735. static_assert(piece.compare(3, 3, "def", 3, 3) == 0, "");
  736. }
  737. TEST(StringPieceTest, Substr) {
  738. constexpr StringPiece piece = "abcdefghijklmnopqrstuvwxyz";
  739. static_assert(piece.substr(0, 2) == "ab", "");
  740. static_assert(piece.substr(0, 3) == "abc", "");
  741. static_assert(piece.substr(0, 4) == "abcd", "");
  742. static_assert(piece.substr(3, 2) == "de", "");
  743. static_assert(piece.substr(3, 3) == "def", "");
  744. static_assert(piece.substr(23) == "xyz", "");
  745. static_assert(piece.substr(23, 3) == "xyz", "");
  746. static_assert(piece.substr(23, 99) == "xyz", "");
  747. static_assert(piece.substr() == piece, "");
  748. static_assert(piece.substr(0) == piece, "");
  749. static_assert(piece.substr(0, 99) == piece, "");
  750. }
  751. TEST(StringPieceTest, Find) {
  752. constexpr StringPiece foobar("foobar", 6);
  753. constexpr StringPiece foo = foobar.substr(0, 3);
  754. constexpr StringPiece bar = foobar.substr(3);
  755. // find
  756. static_assert(foobar.find(bar, 0) == 3, "");
  757. static_assert(foobar.find('o', 0) == 1, "");
  758. static_assert(foobar.find("ox", 0, 1) == 1, "");
  759. static_assert(foobar.find("ox", 0) == StringPiece::npos, "");
  760. // rfind
  761. static_assert(foobar.rfind(bar, 5) == 3, "");
  762. static_assert(foobar.rfind('o', 5) == 2, "");
  763. static_assert(foobar.rfind("ox", 5, 1) == 2, "");
  764. static_assert(foobar.rfind("ox", 5) == StringPiece::npos, "");
  765. // find_first_of
  766. static_assert(foobar.find_first_of(foo, 2) == 2, "");
  767. static_assert(foobar.find_first_of('o', 2) == 2, "");
  768. static_assert(foobar.find_first_of("ox", 2, 2) == 2, "");
  769. static_assert(foobar.find_first_of("ox", 2) == 2, "");
  770. // find_last_of
  771. static_assert(foobar.find_last_of(foo, 5) == 2, "");
  772. static_assert(foobar.find_last_of('o', 5) == 2, "");
  773. static_assert(foobar.find_last_of("ox", 5, 2) == 2, "");
  774. static_assert(foobar.find_last_of("ox", 5) == 2, "");
  775. // find_first_not_of
  776. static_assert(foobar.find_first_not_of(foo, 2) == 3, "");
  777. static_assert(foobar.find_first_not_of('o', 2) == 3, "");
  778. static_assert(foobar.find_first_not_of("ox", 2, 2) == 3, "");
  779. static_assert(foobar.find_first_not_of("ox", 2) == 3, "");
  780. // find_last_not_of
  781. static_assert(foobar.find_last_not_of(bar, 5) == 2, "");
  782. static_assert(foobar.find_last_not_of('a', 4) == 3, "");
  783. static_assert(foobar.find_last_not_of("ox", 2, 2) == 0, "");
  784. static_assert(foobar.find_last_not_of("ox", 2) == 0, "");
  785. }
  786. } // namespace base