1 // Copyright 2017 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "absl/strings/string_view.h"
16
17 #include <stdlib.h>
18
19 #include <cstddef>
20 #include <cstdlib>
21 #include <cstring>
22 #include <iomanip>
23 #include <ios>
24 #include <iterator>
25 #include <limits>
26 #include <map>
27 #include <memory>
28 #include <sstream>
29 #include <string>
30 #include <type_traits>
31 #include <utility>
32
33 #include "gtest/gtest.h"
34 #include "absl/base/config.h"
35
36 #if defined(ABSL_HAVE_STD_STRING_VIEW) || defined(__ANDROID__)
37 // We don't control the death messaging when using std::string_view.
38 // Android assert messages only go to system log, so death tests cannot inspect
39 // the message for matching.
40 #define ABSL_EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
41 EXPECT_DEATH_IF_SUPPORTED(statement, ".*")
42 #else
43 #define ABSL_EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
44 EXPECT_DEATH_IF_SUPPORTED(statement, regex)
45 #endif
46
47 namespace {
48
49 // A minimal allocator that uses malloc().
50 template <typename T>
51 struct Mallocator {
52 typedef T value_type;
53 typedef size_t size_type;
54 typedef ptrdiff_t difference_type;
55 typedef T* pointer;
56 typedef const T* const_pointer;
57 typedef T& reference;
58 typedef const T& const_reference;
59
max_size__anonbb075c750111::Mallocator60 size_type max_size() const {
61 return size_t(std::numeric_limits<size_type>::max()) / sizeof(value_type);
62 }
63 template <typename U>
64 struct rebind {
65 typedef Mallocator<U> other;
66 };
67 Mallocator() = default;
68 template <class U>
Mallocator__anonbb075c750111::Mallocator69 Mallocator(const Mallocator<U>&) {} // NOLINT(runtime/explicit)
70
allocate__anonbb075c750111::Mallocator71 T* allocate(size_t n) { return static_cast<T*>(std::malloc(n * sizeof(T))); }
deallocate__anonbb075c750111::Mallocator72 void deallocate(T* p, size_t) { std::free(p); }
73 };
74 template <typename T, typename U>
operator ==(const Mallocator<T> &,const Mallocator<U> &)75 bool operator==(const Mallocator<T>&, const Mallocator<U>&) {
76 return true;
77 }
78 template <typename T, typename U>
operator !=(const Mallocator<T> &,const Mallocator<U> &)79 bool operator!=(const Mallocator<T>&, const Mallocator<U>&) {
80 return false;
81 }
82
TEST(StringViewTest,Ctor)83 TEST(StringViewTest, Ctor) {
84 {
85 // Null.
86 absl::string_view s10;
87 EXPECT_TRUE(s10.data() == nullptr);
88 EXPECT_EQ(0u, s10.length());
89 }
90
91 {
92 // const char* without length.
93 const char* hello = "hello";
94 absl::string_view s20(hello);
95 EXPECT_TRUE(s20.data() == hello);
96 EXPECT_EQ(5u, s20.length());
97
98 // const char* with length.
99 absl::string_view s21(hello, 4);
100 EXPECT_TRUE(s21.data() == hello);
101 EXPECT_EQ(4u, s21.length());
102
103 // Not recommended, but valid C++
104 absl::string_view s22(hello, 6);
105 EXPECT_TRUE(s22.data() == hello);
106 EXPECT_EQ(6u, s22.length());
107 }
108
109 {
110 // std::string.
111 std::string hola = "hola";
112 absl::string_view s30(hola);
113 EXPECT_TRUE(s30.data() == hola.data());
114 EXPECT_EQ(4u, s30.length());
115
116 // std::string with embedded '\0'.
117 hola.push_back('\0');
118 hola.append("h2");
119 hola.push_back('\0');
120 absl::string_view s31(hola);
121 EXPECT_TRUE(s31.data() == hola.data());
122 EXPECT_EQ(8u, s31.length());
123 }
124
125 {
126 using mstring =
127 std::basic_string<char, std::char_traits<char>, Mallocator<char>>;
128 mstring str1("BUNGIE-JUMPING!");
129 const mstring str2("SLEEPING!");
130
131 absl::string_view s1(str1);
132 s1.remove_prefix(strlen("BUNGIE-JUM"));
133
134 absl::string_view s2(str2);
135 s2.remove_prefix(strlen("SLEE"));
136
137 EXPECT_EQ(s1, s2);
138 EXPECT_EQ(s1, "PING!");
139 }
140
141 // TODO(mec): absl::string_view(const absl::string_view&);
142 }
143
TEST(StringViewTest,Swap)144 TEST(StringViewTest, Swap) {
145 absl::string_view a("a");
146 absl::string_view b("bbb");
147 EXPECT_TRUE(noexcept(a.swap(b)));
148 a.swap(b);
149 EXPECT_EQ(a, "bbb");
150 EXPECT_EQ(b, "a");
151 a.swap(b);
152 EXPECT_EQ(a, "a");
153 EXPECT_EQ(b, "bbb");
154 }
155
TEST(StringViewTest,STLComparator)156 TEST(StringViewTest, STLComparator) {
157 std::string s1("foo");
158 std::string s2("bar");
159 std::string s3("baz");
160
161 absl::string_view p1(s1);
162 absl::string_view p2(s2);
163 absl::string_view p3(s3);
164
165 typedef std::map<absl::string_view, int> TestMap;
166 TestMap map;
167
168 map.insert(std::make_pair(p1, 0));
169 map.insert(std::make_pair(p2, 1));
170 map.insert(std::make_pair(p3, 2));
171 EXPECT_EQ(map.size(), 3u);
172
173 TestMap::const_iterator iter = map.begin();
174 EXPECT_EQ(iter->second, 1);
175 ++iter;
176 EXPECT_EQ(iter->second, 2);
177 ++iter;
178 EXPECT_EQ(iter->second, 0);
179 ++iter;
180 EXPECT_TRUE(iter == map.end());
181
182 TestMap::iterator new_iter = map.find("zot");
183 EXPECT_TRUE(new_iter == map.end());
184
185 new_iter = map.find("bar");
186 EXPECT_TRUE(new_iter != map.end());
187
188 map.erase(new_iter);
189 EXPECT_EQ(map.size(), 2u);
190
191 iter = map.begin();
192 EXPECT_EQ(iter->second, 2);
193 ++iter;
194 EXPECT_EQ(iter->second, 0);
195 ++iter;
196 EXPECT_TRUE(iter == map.end());
197 }
198
199 #define COMPARE(result, op, x, y) \
200 EXPECT_EQ(result, absl::string_view((x)) op absl::string_view((y))); \
201 EXPECT_EQ(result, absl::string_view((x)).compare(absl::string_view((y))) op 0)
202
TEST(StringViewTest,ComparisonOperators)203 TEST(StringViewTest, ComparisonOperators) {
204 COMPARE(true, ==, "", "");
205 COMPARE(true, ==, "", absl::string_view());
206 COMPARE(true, ==, absl::string_view(), "");
207 COMPARE(true, ==, "a", "a");
208 COMPARE(true, ==, "aa", "aa");
209 COMPARE(false, ==, "a", "");
210 COMPARE(false, ==, "", "a");
211 COMPARE(false, ==, "a", "b");
212 COMPARE(false, ==, "a", "aa");
213 COMPARE(false, ==, "aa", "a");
214
215 COMPARE(false, !=, "", "");
216 COMPARE(false, !=, "a", "a");
217 COMPARE(false, !=, "aa", "aa");
218 COMPARE(true, !=, "a", "");
219 COMPARE(true, !=, "", "a");
220 COMPARE(true, !=, "a", "b");
221 COMPARE(true, !=, "a", "aa");
222 COMPARE(true, !=, "aa", "a");
223
224 COMPARE(true, <, "a", "b");
225 COMPARE(true, <, "a", "aa");
226 COMPARE(true, <, "aa", "b");
227 COMPARE(true, <, "aa", "bb");
228 COMPARE(false, <, "a", "a");
229 COMPARE(false, <, "b", "a");
230 COMPARE(false, <, "aa", "a");
231 COMPARE(false, <, "b", "aa");
232 COMPARE(false, <, "bb", "aa");
233
234 COMPARE(true, <=, "a", "a");
235 COMPARE(true, <=, "a", "b");
236 COMPARE(true, <=, "a", "aa");
237 COMPARE(true, <=, "aa", "b");
238 COMPARE(true, <=, "aa", "bb");
239 COMPARE(false, <=, "b", "a");
240 COMPARE(false, <=, "aa", "a");
241 COMPARE(false, <=, "b", "aa");
242 COMPARE(false, <=, "bb", "aa");
243
244 COMPARE(false, >=, "a", "b");
245 COMPARE(false, >=, "a", "aa");
246 COMPARE(false, >=, "aa", "b");
247 COMPARE(false, >=, "aa", "bb");
248 COMPARE(true, >=, "a", "a");
249 COMPARE(true, >=, "b", "a");
250 COMPARE(true, >=, "aa", "a");
251 COMPARE(true, >=, "b", "aa");
252 COMPARE(true, >=, "bb", "aa");
253
254 COMPARE(false, >, "a", "a");
255 COMPARE(false, >, "a", "b");
256 COMPARE(false, >, "a", "aa");
257 COMPARE(false, >, "aa", "b");
258 COMPARE(false, >, "aa", "bb");
259 COMPARE(true, >, "b", "a");
260 COMPARE(true, >, "aa", "a");
261 COMPARE(true, >, "b", "aa");
262 COMPARE(true, >, "bb", "aa");
263 }
264
TEST(StringViewTest,ComparisonOperatorsByCharacterPosition)265 TEST(StringViewTest, ComparisonOperatorsByCharacterPosition) {
266 std::string x;
267 for (size_t i = 0; i < 256; i++) {
268 x += 'a';
269 std::string y = x;
270 COMPARE(true, ==, x, y);
271 for (size_t j = 0; j < i; j++) {
272 std::string z = x;
273 z[j] = 'b'; // Differs in position 'j'
274 COMPARE(false, ==, x, z);
275 COMPARE(true, <, x, z);
276 COMPARE(true, >, z, x);
277 if (j + 1 < i) {
278 z[j + 1] = 'A'; // Differs in position 'j+1' as well
279 COMPARE(false, ==, x, z);
280 COMPARE(true, <, x, z);
281 COMPARE(true, >, z, x);
282 z[j + 1] = 'z'; // Differs in position 'j+1' as well
283 COMPARE(false, ==, x, z);
284 COMPARE(true, <, x, z);
285 COMPARE(true, >, z, x);
286 }
287 }
288 }
289 }
290 #undef COMPARE
291
292 // Sadly, our users often confuse std::string::npos with
293 // absl::string_view::npos; So much so that we test here that they are the same.
294 // They need to both be unsigned, and both be the maximum-valued integer of
295 // their type.
296
297 template <typename T>
298 struct is_type {
299 template <typename U>
same__anonbb075c750111::is_type300 static bool same(U) {
301 return false;
302 }
same__anonbb075c750111::is_type303 static bool same(T) { return true; }
304 };
305
TEST(StringViewTest,NposMatchesStdStringView)306 TEST(StringViewTest, NposMatchesStdStringView) {
307 EXPECT_EQ(absl::string_view::npos, std::string::npos);
308
309 EXPECT_TRUE(is_type<size_t>::same(absl::string_view::npos));
310 EXPECT_FALSE(is_type<size_t>::same(""));
311
312 // Make sure absl::string_view::npos continues to be a header constant.
313 char test[absl::string_view::npos & 1] = {0};
314 EXPECT_EQ(0, test[0]);
315 }
316
TEST(StringViewTest,STL1)317 TEST(StringViewTest, STL1) {
318 const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
319 const absl::string_view b("abc");
320 const absl::string_view c("xyz");
321 const absl::string_view d("foobar");
322 const absl::string_view e;
323 std::string temp("123");
324 temp += '\0';
325 temp += "456";
326 const absl::string_view f(temp);
327
328 EXPECT_EQ(a[6], 'g');
329 EXPECT_EQ(b[0], 'a');
330 EXPECT_EQ(c[2], 'z');
331 EXPECT_EQ(f[3], '\0');
332 EXPECT_EQ(f[5], '5');
333
334 EXPECT_EQ(*d.data(), 'f');
335 EXPECT_EQ(d.data()[5], 'r');
336 EXPECT_TRUE(e.data() == nullptr);
337
338 EXPECT_EQ(*a.begin(), 'a');
339 EXPECT_EQ(*(b.begin() + 2), 'c');
340 EXPECT_EQ(*(c.end() - 1), 'z');
341
342 EXPECT_EQ(*a.rbegin(), 'z');
343 EXPECT_EQ(*(b.rbegin() + 2), 'a');
344 EXPECT_EQ(*(c.rend() - 1), 'x');
345 EXPECT_TRUE(a.rbegin() + 26 == a.rend());
346
347 EXPECT_EQ(a.size(), 26u);
348 EXPECT_EQ(b.size(), 3u);
349 EXPECT_EQ(c.size(), 3u);
350 EXPECT_EQ(d.size(), 6u);
351 EXPECT_EQ(e.size(), 0u);
352 EXPECT_EQ(f.size(), 7u);
353
354 EXPECT_TRUE(!d.empty());
355 EXPECT_TRUE(d.begin() != d.end());
356 EXPECT_TRUE(d.begin() + 6 == d.end());
357
358 EXPECT_TRUE(e.empty());
359 EXPECT_TRUE(e.begin() == e.end());
360
361 char buf[4] = { '%', '%', '%', '%' };
362 EXPECT_EQ(a.copy(buf, 4), 4u);
363 EXPECT_EQ(buf[0], a[0]);
364 EXPECT_EQ(buf[1], a[1]);
365 EXPECT_EQ(buf[2], a[2]);
366 EXPECT_EQ(buf[3], a[3]);
367 EXPECT_EQ(a.copy(buf, 3, 7), 3u);
368 EXPECT_EQ(buf[0], a[7]);
369 EXPECT_EQ(buf[1], a[8]);
370 EXPECT_EQ(buf[2], a[9]);
371 EXPECT_EQ(buf[3], a[3]);
372 EXPECT_EQ(c.copy(buf, 99), 3u);
373 EXPECT_EQ(buf[0], c[0]);
374 EXPECT_EQ(buf[1], c[1]);
375 EXPECT_EQ(buf[2], c[2]);
376 EXPECT_EQ(buf[3], a[3]);
377 #ifdef ABSL_HAVE_EXCEPTIONS
378 EXPECT_THROW(a.copy(buf, 1, 27), std::out_of_range);
379 #else
380 ABSL_EXPECT_DEATH_IF_SUPPORTED(a.copy(buf, 1, 27), "absl::string_view::copy");
381 #endif
382 }
383
384 // Separated from STL1() because some compilers produce an overly
385 // large stack frame for the combined function.
TEST(StringViewTest,STL2)386 TEST(StringViewTest, STL2) {
387 const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
388 const absl::string_view b("abc");
389 const absl::string_view c("xyz");
390 absl::string_view d("foobar");
391 const absl::string_view e;
392 const absl::string_view f(
393 "123"
394 "\0"
395 "456",
396 7);
397
398 d = absl::string_view();
399 EXPECT_EQ(d.size(), 0u);
400 EXPECT_TRUE(d.empty());
401 EXPECT_TRUE(d.data() == nullptr);
402 EXPECT_TRUE(d.begin() == d.end());
403
404 EXPECT_EQ(a.find(b), 0u);
405 EXPECT_EQ(a.find(b, 1), absl::string_view::npos);
406 EXPECT_EQ(a.find(c), 23u);
407 EXPECT_EQ(a.find(c, 9), 23u);
408 EXPECT_EQ(a.find(c, absl::string_view::npos), absl::string_view::npos);
409 EXPECT_EQ(b.find(c), absl::string_view::npos);
410 EXPECT_EQ(b.find(c, absl::string_view::npos), absl::string_view::npos);
411 EXPECT_EQ(a.find(d), 0u);
412 EXPECT_EQ(a.find(e), 0u);
413 EXPECT_EQ(a.find(d, 12), 12u);
414 EXPECT_EQ(a.find(e, 17), 17u);
415 absl::string_view g("xx not found bb");
416 EXPECT_EQ(a.find(g), absl::string_view::npos);
417 // empty string nonsense
418 EXPECT_EQ(d.find(b), absl::string_view::npos);
419 EXPECT_EQ(e.find(b), absl::string_view::npos);
420 EXPECT_EQ(d.find(b, 4), absl::string_view::npos);
421 EXPECT_EQ(e.find(b, 7), absl::string_view::npos);
422
423 size_t empty_search_pos = std::string().find(std::string());
424 EXPECT_EQ(d.find(d), empty_search_pos);
425 EXPECT_EQ(d.find(e), empty_search_pos);
426 EXPECT_EQ(e.find(d), empty_search_pos);
427 EXPECT_EQ(e.find(e), empty_search_pos);
428 EXPECT_EQ(d.find(d, 4), std::string().find(std::string(), 4));
429 EXPECT_EQ(d.find(e, 4), std::string().find(std::string(), 4));
430 EXPECT_EQ(e.find(d, 4), std::string().find(std::string(), 4));
431 EXPECT_EQ(e.find(e, 4), std::string().find(std::string(), 4));
432
433 EXPECT_EQ(a.find('a'), 0u);
434 EXPECT_EQ(a.find('c'), 2u);
435 EXPECT_EQ(a.find('z'), 25u);
436 EXPECT_EQ(a.find('$'), absl::string_view::npos);
437 EXPECT_EQ(a.find('\0'), absl::string_view::npos);
438 EXPECT_EQ(f.find('\0'), 3u);
439 EXPECT_EQ(f.find('3'), 2u);
440 EXPECT_EQ(f.find('5'), 5u);
441 EXPECT_EQ(g.find('o'), 4u);
442 EXPECT_EQ(g.find('o', 4), 4u);
443 EXPECT_EQ(g.find('o', 5), 8u);
444 EXPECT_EQ(a.find('b', 5), absl::string_view::npos);
445 // empty string nonsense
446 EXPECT_EQ(d.find('\0'), absl::string_view::npos);
447 EXPECT_EQ(e.find('\0'), absl::string_view::npos);
448 EXPECT_EQ(d.find('\0', 4), absl::string_view::npos);
449 EXPECT_EQ(e.find('\0', 7), absl::string_view::npos);
450 EXPECT_EQ(d.find('x'), absl::string_view::npos);
451 EXPECT_EQ(e.find('x'), absl::string_view::npos);
452 EXPECT_EQ(d.find('x', 4), absl::string_view::npos);
453 EXPECT_EQ(e.find('x', 7), absl::string_view::npos);
454
455 EXPECT_EQ(a.find(b.data(), 1, 0), 1u);
456 EXPECT_EQ(a.find(c.data(), 9, 0), 9u);
457 EXPECT_EQ(a.find(c.data(), absl::string_view::npos, 0),
458 absl::string_view::npos);
459 EXPECT_EQ(b.find(c.data(), absl::string_view::npos, 0),
460 absl::string_view::npos);
461 // empty string nonsense
462 EXPECT_EQ(d.find(b.data(), 4, 0), absl::string_view::npos);
463 EXPECT_EQ(e.find(b.data(), 7, 0), absl::string_view::npos);
464
465 EXPECT_EQ(a.find(b.data(), 1), absl::string_view::npos);
466 EXPECT_EQ(a.find(c.data(), 9), 23u);
467 EXPECT_EQ(a.find(c.data(), absl::string_view::npos), absl::string_view::npos);
468 EXPECT_EQ(b.find(c.data(), absl::string_view::npos), absl::string_view::npos);
469 // empty string nonsense
470 EXPECT_EQ(d.find(b.data(), 4), absl::string_view::npos);
471 EXPECT_EQ(e.find(b.data(), 7), absl::string_view::npos);
472
473 EXPECT_EQ(a.rfind(b), 0u);
474 EXPECT_EQ(a.rfind(b, 1), 0u);
475 EXPECT_EQ(a.rfind(c), 23u);
476 EXPECT_EQ(a.rfind(c, 22), absl::string_view::npos);
477 EXPECT_EQ(a.rfind(c, 1), absl::string_view::npos);
478 EXPECT_EQ(a.rfind(c, 0), absl::string_view::npos);
479 EXPECT_EQ(b.rfind(c), absl::string_view::npos);
480 EXPECT_EQ(b.rfind(c, 0), absl::string_view::npos);
481 EXPECT_EQ(a.rfind(d), std::string(a).rfind(std::string()));
482 EXPECT_EQ(a.rfind(e), std::string(a).rfind(std::string()));
483 EXPECT_EQ(a.rfind(d, 12), 12u);
484 EXPECT_EQ(a.rfind(e, 17), 17u);
485 EXPECT_EQ(a.rfind(g), absl::string_view::npos);
486 EXPECT_EQ(d.rfind(b), absl::string_view::npos);
487 EXPECT_EQ(e.rfind(b), absl::string_view::npos);
488 EXPECT_EQ(d.rfind(b, 4), absl::string_view::npos);
489 EXPECT_EQ(e.rfind(b, 7), absl::string_view::npos);
490 // empty string nonsense
491 EXPECT_EQ(d.rfind(d, 4), std::string().rfind(std::string()));
492 EXPECT_EQ(e.rfind(d, 7), std::string().rfind(std::string()));
493 EXPECT_EQ(d.rfind(e, 4), std::string().rfind(std::string()));
494 EXPECT_EQ(e.rfind(e, 7), std::string().rfind(std::string()));
495 EXPECT_EQ(d.rfind(d), std::string().rfind(std::string()));
496 EXPECT_EQ(e.rfind(d), std::string().rfind(std::string()));
497 EXPECT_EQ(d.rfind(e), std::string().rfind(std::string()));
498 EXPECT_EQ(e.rfind(e), std::string().rfind(std::string()));
499
500 EXPECT_EQ(g.rfind('o'), 8u);
501 EXPECT_EQ(g.rfind('q'), absl::string_view::npos);
502 EXPECT_EQ(g.rfind('o', 8), 8u);
503 EXPECT_EQ(g.rfind('o', 7), 4u);
504 EXPECT_EQ(g.rfind('o', 3), absl::string_view::npos);
505 EXPECT_EQ(f.rfind('\0'), 3u);
506 EXPECT_EQ(f.rfind('\0', 12), 3u);
507 EXPECT_EQ(f.rfind('3'), 2u);
508 EXPECT_EQ(f.rfind('5'), 5u);
509 // empty string nonsense
510 EXPECT_EQ(d.rfind('o'), absl::string_view::npos);
511 EXPECT_EQ(e.rfind('o'), absl::string_view::npos);
512 EXPECT_EQ(d.rfind('o', 4), absl::string_view::npos);
513 EXPECT_EQ(e.rfind('o', 7), absl::string_view::npos);
514
515 EXPECT_EQ(a.rfind(b.data(), 1, 0), 1u);
516 EXPECT_EQ(a.rfind(c.data(), 22, 0), 22u);
517 EXPECT_EQ(a.rfind(c.data(), 1, 0), 1u);
518 EXPECT_EQ(a.rfind(c.data(), 0, 0), 0u);
519 EXPECT_EQ(b.rfind(c.data(), 0, 0), 0u);
520 EXPECT_EQ(d.rfind(b.data(), 4, 0), 0u);
521 EXPECT_EQ(e.rfind(b.data(), 7, 0), 0u);
522 }
523
524 // Continued from STL2
TEST(StringViewTest,STL2FindFirst)525 TEST(StringViewTest, STL2FindFirst) {
526 const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
527 const absl::string_view b("abc");
528 const absl::string_view c("xyz");
529 absl::string_view d("foobar");
530 const absl::string_view e;
531 const absl::string_view f(
532 "123"
533 "\0"
534 "456",
535 7);
536 absl::string_view g("xx not found bb");
537
538 d = absl::string_view();
539 EXPECT_EQ(a.find_first_of(b), 0u);
540 EXPECT_EQ(a.find_first_of(b, 0), 0u);
541 EXPECT_EQ(a.find_first_of(b, 1), 1u);
542 EXPECT_EQ(a.find_first_of(b, 2), 2u);
543 EXPECT_EQ(a.find_first_of(b, 3), absl::string_view::npos);
544 EXPECT_EQ(a.find_first_of(c), 23u);
545 EXPECT_EQ(a.find_first_of(c, 23), 23u);
546 EXPECT_EQ(a.find_first_of(c, 24), 24u);
547 EXPECT_EQ(a.find_first_of(c, 25), 25u);
548 EXPECT_EQ(a.find_first_of(c, 26), absl::string_view::npos);
549 EXPECT_EQ(g.find_first_of(b), 13u);
550 EXPECT_EQ(g.find_first_of(c), 0u);
551 EXPECT_EQ(a.find_first_of(f), absl::string_view::npos);
552 EXPECT_EQ(f.find_first_of(a), absl::string_view::npos);
553 // empty string nonsense
554 EXPECT_EQ(a.find_first_of(d), absl::string_view::npos);
555 EXPECT_EQ(a.find_first_of(e), absl::string_view::npos);
556 EXPECT_EQ(d.find_first_of(b), absl::string_view::npos);
557 EXPECT_EQ(e.find_first_of(b), absl::string_view::npos);
558 EXPECT_EQ(d.find_first_of(d), absl::string_view::npos);
559 EXPECT_EQ(e.find_first_of(d), absl::string_view::npos);
560 EXPECT_EQ(d.find_first_of(e), absl::string_view::npos);
561 EXPECT_EQ(e.find_first_of(e), absl::string_view::npos);
562
563 EXPECT_EQ(a.find_first_not_of(b), 3u);
564 EXPECT_EQ(a.find_first_not_of(c), 0u);
565 EXPECT_EQ(b.find_first_not_of(a), absl::string_view::npos);
566 EXPECT_EQ(c.find_first_not_of(a), absl::string_view::npos);
567 EXPECT_EQ(f.find_first_not_of(a), 0u);
568 EXPECT_EQ(a.find_first_not_of(f), 0u);
569 EXPECT_EQ(a.find_first_not_of(d), 0u);
570 EXPECT_EQ(a.find_first_not_of(e), 0u);
571 // empty string nonsense
572 EXPECT_EQ(a.find_first_not_of(d), 0u);
573 EXPECT_EQ(a.find_first_not_of(e), 0u);
574 EXPECT_EQ(a.find_first_not_of(d, 1), 1u);
575 EXPECT_EQ(a.find_first_not_of(e, 1), 1u);
576 EXPECT_EQ(a.find_first_not_of(d, a.size() - 1), a.size() - 1);
577 EXPECT_EQ(a.find_first_not_of(e, a.size() - 1), a.size() - 1);
578 EXPECT_EQ(a.find_first_not_of(d, a.size()), absl::string_view::npos);
579 EXPECT_EQ(a.find_first_not_of(e, a.size()), absl::string_view::npos);
580 EXPECT_EQ(a.find_first_not_of(d, absl::string_view::npos),
581 absl::string_view::npos);
582 EXPECT_EQ(a.find_first_not_of(e, absl::string_view::npos),
583 absl::string_view::npos);
584 EXPECT_EQ(d.find_first_not_of(a), absl::string_view::npos);
585 EXPECT_EQ(e.find_first_not_of(a), absl::string_view::npos);
586 EXPECT_EQ(d.find_first_not_of(d), absl::string_view::npos);
587 EXPECT_EQ(e.find_first_not_of(d), absl::string_view::npos);
588 EXPECT_EQ(d.find_first_not_of(e), absl::string_view::npos);
589 EXPECT_EQ(e.find_first_not_of(e), absl::string_view::npos);
590
591 absl::string_view h("====");
592 EXPECT_EQ(h.find_first_not_of('='), absl::string_view::npos);
593 EXPECT_EQ(h.find_first_not_of('=', 3), absl::string_view::npos);
594 EXPECT_EQ(h.find_first_not_of('\0'), 0u);
595 EXPECT_EQ(g.find_first_not_of('x'), 2u);
596 EXPECT_EQ(f.find_first_not_of('\0'), 0u);
597 EXPECT_EQ(f.find_first_not_of('\0', 3), 4u);
598 EXPECT_EQ(f.find_first_not_of('\0', 2), 2u);
599 // empty string nonsense
600 EXPECT_EQ(d.find_first_not_of('x'), absl::string_view::npos);
601 EXPECT_EQ(e.find_first_not_of('x'), absl::string_view::npos);
602 EXPECT_EQ(d.find_first_not_of('\0'), absl::string_view::npos);
603 EXPECT_EQ(e.find_first_not_of('\0'), absl::string_view::npos);
604 }
605
606 // Continued from STL2
TEST(StringViewTest,STL2FindLast)607 TEST(StringViewTest, STL2FindLast) {
608 const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
609 const absl::string_view b("abc");
610 const absl::string_view c("xyz");
611 absl::string_view d("foobar");
612 const absl::string_view e;
613 const absl::string_view f(
614 "123"
615 "\0"
616 "456",
617 7);
618 absl::string_view g("xx not found bb");
619 absl::string_view h("====");
620 absl::string_view i("56");
621
622 d = absl::string_view();
623 EXPECT_EQ(h.find_last_of(a), absl::string_view::npos);
624 EXPECT_EQ(g.find_last_of(a), g.size() - 1);
625 EXPECT_EQ(a.find_last_of(b), 2u);
626 EXPECT_EQ(a.find_last_of(c), a.size() - 1);
627 EXPECT_EQ(f.find_last_of(i), 6u);
628 EXPECT_EQ(a.find_last_of('a'), 0u);
629 EXPECT_EQ(a.find_last_of('b'), 1u);
630 EXPECT_EQ(a.find_last_of('z'), 25u);
631 EXPECT_EQ(a.find_last_of('a', 5), 0u);
632 EXPECT_EQ(a.find_last_of('b', 5), 1u);
633 EXPECT_EQ(a.find_last_of('b', 0), absl::string_view::npos);
634 EXPECT_EQ(a.find_last_of('z', 25), 25u);
635 EXPECT_EQ(a.find_last_of('z', 24), absl::string_view::npos);
636 EXPECT_EQ(f.find_last_of(i, 5), 5u);
637 EXPECT_EQ(f.find_last_of(i, 6), 6u);
638 EXPECT_EQ(f.find_last_of(a, 4), absl::string_view::npos);
639 // empty string nonsense
640 EXPECT_EQ(f.find_last_of(d), absl::string_view::npos);
641 EXPECT_EQ(f.find_last_of(e), absl::string_view::npos);
642 EXPECT_EQ(f.find_last_of(d, 4), absl::string_view::npos);
643 EXPECT_EQ(f.find_last_of(e, 4), absl::string_view::npos);
644 EXPECT_EQ(d.find_last_of(d), absl::string_view::npos);
645 EXPECT_EQ(d.find_last_of(e), absl::string_view::npos);
646 EXPECT_EQ(e.find_last_of(d), absl::string_view::npos);
647 EXPECT_EQ(e.find_last_of(e), absl::string_view::npos);
648 EXPECT_EQ(d.find_last_of(f), absl::string_view::npos);
649 EXPECT_EQ(e.find_last_of(f), absl::string_view::npos);
650 EXPECT_EQ(d.find_last_of(d, 4), absl::string_view::npos);
651 EXPECT_EQ(d.find_last_of(e, 4), absl::string_view::npos);
652 EXPECT_EQ(e.find_last_of(d, 4), absl::string_view::npos);
653 EXPECT_EQ(e.find_last_of(e, 4), absl::string_view::npos);
654 EXPECT_EQ(d.find_last_of(f, 4), absl::string_view::npos);
655 EXPECT_EQ(e.find_last_of(f, 4), absl::string_view::npos);
656
657 EXPECT_EQ(a.find_last_not_of(b), a.size() - 1);
658 EXPECT_EQ(a.find_last_not_of(c), 22u);
659 EXPECT_EQ(b.find_last_not_of(a), absl::string_view::npos);
660 EXPECT_EQ(b.find_last_not_of(b), absl::string_view::npos);
661 EXPECT_EQ(f.find_last_not_of(i), 4u);
662 EXPECT_EQ(a.find_last_not_of(c, 24), 22u);
663 EXPECT_EQ(a.find_last_not_of(b, 3), 3u);
664 EXPECT_EQ(a.find_last_not_of(b, 2), absl::string_view::npos);
665 // empty string nonsense
666 EXPECT_EQ(f.find_last_not_of(d), f.size() - 1);
667 EXPECT_EQ(f.find_last_not_of(e), f.size() - 1);
668 EXPECT_EQ(f.find_last_not_of(d, 4), 4u);
669 EXPECT_EQ(f.find_last_not_of(e, 4), 4u);
670 EXPECT_EQ(d.find_last_not_of(d), absl::string_view::npos);
671 EXPECT_EQ(d.find_last_not_of(e), absl::string_view::npos);
672 EXPECT_EQ(e.find_last_not_of(d), absl::string_view::npos);
673 EXPECT_EQ(e.find_last_not_of(e), absl::string_view::npos);
674 EXPECT_EQ(d.find_last_not_of(f), absl::string_view::npos);
675 EXPECT_EQ(e.find_last_not_of(f), absl::string_view::npos);
676 EXPECT_EQ(d.find_last_not_of(d, 4), absl::string_view::npos);
677 EXPECT_EQ(d.find_last_not_of(e, 4), absl::string_view::npos);
678 EXPECT_EQ(e.find_last_not_of(d, 4), absl::string_view::npos);
679 EXPECT_EQ(e.find_last_not_of(e, 4), absl::string_view::npos);
680 EXPECT_EQ(d.find_last_not_of(f, 4), absl::string_view::npos);
681 EXPECT_EQ(e.find_last_not_of(f, 4), absl::string_view::npos);
682
683 EXPECT_EQ(h.find_last_not_of('x'), h.size() - 1);
684 EXPECT_EQ(h.find_last_not_of('='), absl::string_view::npos);
685 EXPECT_EQ(b.find_last_not_of('c'), 1u);
686 EXPECT_EQ(h.find_last_not_of('x', 2), 2u);
687 EXPECT_EQ(h.find_last_not_of('=', 2), absl::string_view::npos);
688 EXPECT_EQ(b.find_last_not_of('b', 1), 0u);
689 // empty string nonsense
690 EXPECT_EQ(d.find_last_not_of('x'), absl::string_view::npos);
691 EXPECT_EQ(e.find_last_not_of('x'), absl::string_view::npos);
692 EXPECT_EQ(d.find_last_not_of('\0'), absl::string_view::npos);
693 EXPECT_EQ(e.find_last_not_of('\0'), absl::string_view::npos);
694 }
695
696 // Continued from STL2
TEST(StringViewTest,STL2Substr)697 TEST(StringViewTest, STL2Substr) {
698 const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
699 const absl::string_view b("abc");
700 const absl::string_view c("xyz");
701 absl::string_view d("foobar");
702 const absl::string_view e;
703
704 d = absl::string_view();
705 EXPECT_EQ(a.substr(0, 3), b);
706 EXPECT_EQ(a.substr(23), c);
707 EXPECT_EQ(a.substr(23, 3), c);
708 EXPECT_EQ(a.substr(23, 99), c);
709 EXPECT_EQ(a.substr(0), a);
710 EXPECT_EQ(a.substr(), a);
711 EXPECT_EQ(a.substr(3, 2), "de");
712 // empty string nonsense
713 EXPECT_EQ(d.substr(0, 99), e);
714 // use of npos
715 EXPECT_EQ(a.substr(0, absl::string_view::npos), a);
716 EXPECT_EQ(a.substr(23, absl::string_view::npos), c);
717 // throw exception
718 #ifdef ABSL_HAVE_EXCEPTIONS
719 EXPECT_THROW((void)a.substr(99, 2), std::out_of_range);
720 #else
721 ABSL_EXPECT_DEATH_IF_SUPPORTED((void)a.substr(99, 2),
722 "absl::string_view::substr");
723 #endif
724 }
725
TEST(StringViewTest,TruncSubstr)726 TEST(StringViewTest, TruncSubstr) {
727 const absl::string_view hi("hi");
728 EXPECT_EQ("", absl::ClippedSubstr(hi, 0, 0));
729 EXPECT_EQ("h", absl::ClippedSubstr(hi, 0, 1));
730 EXPECT_EQ("hi", absl::ClippedSubstr(hi, 0));
731 EXPECT_EQ("i", absl::ClippedSubstr(hi, 1));
732 EXPECT_EQ("", absl::ClippedSubstr(hi, 2));
733 EXPECT_EQ("", absl::ClippedSubstr(hi, 3)); // truncation
734 EXPECT_EQ("", absl::ClippedSubstr(hi, 3, 2)); // truncation
735 }
736
TEST(StringViewTest,UTF8)737 TEST(StringViewTest, UTF8) {
738 std::string utf8 = "\u00E1";
739 std::string utf8_twice = utf8 + " " + utf8;
740 size_t utf8_len = strlen(utf8.data());
741 EXPECT_EQ(utf8_len, absl::string_view(utf8_twice).find_first_of(" "));
742 EXPECT_EQ(utf8_len, absl::string_view(utf8_twice).find_first_of(" \t"));
743 }
744
TEST(StringViewTest,FindConformance)745 TEST(StringViewTest, FindConformance) {
746 struct {
747 std::string haystack;
748 std::string needle;
749 } specs[] = {
750 {"", ""},
751 {"", "a"},
752 {"a", ""},
753 {"a", "a"},
754 {"a", "b"},
755 {"aa", ""},
756 {"aa", "a"},
757 {"aa", "b"},
758 {"ab", "a"},
759 {"ab", "b"},
760 {"abcd", ""},
761 {"abcd", "a"},
762 {"abcd", "d"},
763 {"abcd", "ab"},
764 {"abcd", "bc"},
765 {"abcd", "cd"},
766 {"abcd", "abcd"},
767 };
768 for (const auto& s : specs) {
769 SCOPED_TRACE(s.haystack);
770 SCOPED_TRACE(s.needle);
771 std::string st = s.haystack;
772 absl::string_view sp = s.haystack;
773 for (size_t i = 0; i <= sp.size(); ++i) {
774 size_t pos = (i == sp.size()) ? absl::string_view::npos : i;
775 SCOPED_TRACE(pos);
776 EXPECT_EQ(sp.find(s.needle, pos),
777 st.find(s.needle, pos));
778 EXPECT_EQ(sp.rfind(s.needle, pos),
779 st.rfind(s.needle, pos));
780 EXPECT_EQ(sp.find_first_of(s.needle, pos),
781 st.find_first_of(s.needle, pos));
782 EXPECT_EQ(sp.find_first_not_of(s.needle, pos),
783 st.find_first_not_of(s.needle, pos));
784 EXPECT_EQ(sp.find_last_of(s.needle, pos),
785 st.find_last_of(s.needle, pos));
786 EXPECT_EQ(sp.find_last_not_of(s.needle, pos),
787 st.find_last_not_of(s.needle, pos));
788 }
789 }
790 }
791
TEST(StringViewTest,Remove)792 TEST(StringViewTest, Remove) {
793 absl::string_view a("foobar");
794 std::string s1("123");
795 s1 += '\0';
796 s1 += "456";
797 absl::string_view e;
798 std::string s2;
799
800 // remove_prefix
801 absl::string_view c(a);
802 c.remove_prefix(3);
803 EXPECT_EQ(c, "bar");
804 c = a;
805 c.remove_prefix(0);
806 EXPECT_EQ(c, a);
807 c.remove_prefix(c.size());
808 EXPECT_EQ(c, e);
809
810 // remove_suffix
811 c = a;
812 c.remove_suffix(3);
813 EXPECT_EQ(c, "foo");
814 c = a;
815 c.remove_suffix(0);
816 EXPECT_EQ(c, a);
817 c.remove_suffix(c.size());
818 EXPECT_EQ(c, e);
819 }
820
TEST(StringViewTest,Set)821 TEST(StringViewTest, Set) {
822 absl::string_view a("foobar");
823 absl::string_view empty;
824 absl::string_view b;
825
826 // set
827 b = absl::string_view("foobar", 6);
828 EXPECT_EQ(b, a);
829 b = absl::string_view("foobar", 0);
830 EXPECT_EQ(b, empty);
831 b = absl::string_view("foobar", 7);
832 EXPECT_NE(b, a);
833
834 b = absl::string_view("foobar");
835 EXPECT_EQ(b, a);
836 }
837
TEST(StringViewTest,FrontBack)838 TEST(StringViewTest, FrontBack) {
839 static const char arr[] = "abcd";
840 const absl::string_view csp(arr, 4);
841 EXPECT_EQ(&arr[0], &csp.front());
842 EXPECT_EQ(&arr[3], &csp.back());
843 }
844
TEST(StringViewTest,FrontBackSingleChar)845 TEST(StringViewTest, FrontBackSingleChar) {
846 static const char c = 'a';
847 const absl::string_view csp(&c, 1);
848 EXPECT_EQ(&c, &csp.front());
849 EXPECT_EQ(&c, &csp.back());
850 }
851
TEST(StringViewTest,FrontBackEmpty)852 TEST(StringViewTest, FrontBackEmpty) {
853 #ifndef ABSL_USES_STD_STRING_VIEW
854 #if !defined(NDEBUG) || ABSL_OPTION_HARDENED
855 // Abseil's string_view implementation has debug assertions that check that
856 // front() and back() are not called on an empty string_view.
857 absl::string_view sv;
858 ABSL_EXPECT_DEATH_IF_SUPPORTED(sv.front(), "");
859 ABSL_EXPECT_DEATH_IF_SUPPORTED(sv.back(), "");
860 #endif
861 #endif
862 }
863
864 // `std::string_view::string_view(const char*)` calls
865 // `std::char_traits<char>::length(const char*)` to get the string length. In
866 // libc++, it doesn't allow `nullptr` in the constexpr context, with the error
867 // "read of dereferenced null pointer is not allowed in a constant expression".
868 // At run time, the behavior of `std::char_traits::length()` on `nullptr` is
869 // undefined by the standard and usually results in crash with libc++.
870 // GCC also started rejected this in libstdc++ starting in GCC9.
871 // In MSVC, creating a constexpr string_view from nullptr also triggers an
872 // "unevaluable pointer value" error. This compiler implementation conforms
873 // to the standard, but `absl::string_view` implements a different
874 // behavior for historical reasons. We work around tests that construct
875 // `string_view` from `nullptr` when using libc++.
876 #if !defined(ABSL_USES_STD_STRING_VIEW) || \
877 (!(defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 9) && \
878 !defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
879 #define ABSL_HAVE_STRING_VIEW_FROM_NULLPTR 1
880 #endif
881
TEST(StringViewTest,NULLInput)882 TEST(StringViewTest, NULLInput) {
883 absl::string_view s;
884 EXPECT_EQ(s.data(), nullptr);
885 EXPECT_EQ(s.size(), 0u);
886
887 #ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
888 s = absl::string_view(nullptr);
889 EXPECT_EQ(s.data(), nullptr);
890 EXPECT_EQ(s.size(), 0u);
891
892 // .ToString() on a absl::string_view with nullptr should produce the empty
893 // string.
894 EXPECT_EQ("", std::string(s));
895 #endif // ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
896 }
897
TEST(StringViewTest,Comparisons2)898 TEST(StringViewTest, Comparisons2) {
899 // The `compare` member has 6 overloads (v: string_view, s: const char*):
900 // (1) compare(v)
901 // (2) compare(pos1, count1, v)
902 // (3) compare(pos1, count1, v, pos2, count2)
903 // (4) compare(s)
904 // (5) compare(pos1, count1, s)
905 // (6) compare(pos1, count1, s, count2)
906
907 absl::string_view abc("abcdefghijklmnopqrstuvwxyz");
908
909 // check comparison operations on strings longer than 4 bytes.
910 EXPECT_EQ(abc, absl::string_view("abcdefghijklmnopqrstuvwxyz"));
911 EXPECT_EQ(abc.compare(absl::string_view("abcdefghijklmnopqrstuvwxyz")), 0);
912
913 EXPECT_LT(abc, absl::string_view("abcdefghijklmnopqrstuvwxzz"));
914 EXPECT_LT(abc.compare(absl::string_view("abcdefghijklmnopqrstuvwxzz")), 0);
915
916 EXPECT_GT(abc, absl::string_view("abcdefghijklmnopqrstuvwxyy"));
917 EXPECT_GT(abc.compare(absl::string_view("abcdefghijklmnopqrstuvwxyy")), 0);
918
919 // The "substr" variants of `compare`.
920 absl::string_view digits("0123456789");
921 auto npos = absl::string_view::npos;
922
923 // Taking string_view
924 EXPECT_EQ(digits.compare(3, npos, absl::string_view("3456789")), 0); // 2
925 EXPECT_EQ(digits.compare(3, 4, absl::string_view("3456")), 0); // 2
926 EXPECT_EQ(digits.compare(10, 0, absl::string_view()), 0); // 2
927 EXPECT_EQ(digits.compare(3, 4, absl::string_view("0123456789"), 3, 4),
928 0); // 3
929 EXPECT_LT(digits.compare(3, 4, absl::string_view("0123456789"), 3, 5),
930 0); // 3
931 EXPECT_LT(digits.compare(0, npos, absl::string_view("0123456789"), 3, 5),
932 0); // 3
933 // Taking const char*
934 EXPECT_EQ(digits.compare(3, 4, "3456"), 0); // 5
935 EXPECT_EQ(digits.compare(3, npos, "3456789"), 0); // 5
936 EXPECT_EQ(digits.compare(10, 0, ""), 0); // 5
937 EXPECT_EQ(digits.compare(3, 4, "0123456789", 3, 4), 0); // 6
938 EXPECT_LT(digits.compare(3, 4, "0123456789", 3, 5), 0); // 6
939 EXPECT_LT(digits.compare(0, npos, "0123456789", 3, 5), 0); // 6
940 }
941
TEST(StringViewTest,At)942 TEST(StringViewTest, At) {
943 absl::string_view abc = "abc";
944 EXPECT_EQ(abc.at(0), 'a');
945 EXPECT_EQ(abc.at(1), 'b');
946 EXPECT_EQ(abc.at(2), 'c');
947 #ifdef ABSL_HAVE_EXCEPTIONS
948 EXPECT_THROW((void)abc.at(3), std::out_of_range);
949 #else
950 ABSL_EXPECT_DEATH_IF_SUPPORTED((void)abc.at(3), "absl::string_view::at");
951 #endif
952 }
953
954 #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
TEST(StringViewTest,StartsWith)955 TEST(StringViewTest, StartsWith) {
956 const absl::string_view a("foobar");
957 const absl::string_view b("123\0abc", 7);
958 const absl::string_view e;
959 EXPECT_TRUE(a.starts_with(a));
960 EXPECT_TRUE(a.starts_with("foo"));
961 EXPECT_TRUE(a.starts_with('f'));
962 EXPECT_TRUE(a.starts_with(e));
963 EXPECT_TRUE(b.starts_with(b));
964 EXPECT_TRUE(b.starts_with('1'));
965 EXPECT_TRUE(b.starts_with(e));
966 EXPECT_TRUE(e.starts_with(""));
967 EXPECT_FALSE(a.starts_with(b));
968 EXPECT_FALSE(b.starts_with(a));
969 EXPECT_FALSE(e.starts_with(a));
970 EXPECT_FALSE(a.starts_with('r'));
971 EXPECT_FALSE(a.starts_with('\0'));
972 EXPECT_FALSE(e.starts_with('r'));
973 EXPECT_FALSE(e.starts_with('\0'));
974
975 // Test that constexpr compiles.
976 constexpr absl::string_view kFooBar("foobar");
977 constexpr absl::string_view kFoo("foo");
978 constexpr absl::string_view kBar("bar");
979 constexpr bool k1 = kFooBar.starts_with(kFoo);
980 EXPECT_TRUE(k1);
981 constexpr bool k2 = kFooBar.starts_with(kBar);
982 EXPECT_FALSE(k2);
983 constexpr bool k3 = kFooBar.starts_with('f');
984 EXPECT_TRUE(k3);
985 constexpr bool k4 = kFooBar.starts_with("fo");
986 EXPECT_TRUE(k4);
987 }
988
TEST(StringViewTest,EndsWith)989 TEST(StringViewTest, EndsWith) {
990 const absl::string_view a("foobar");
991 const absl::string_view b("123\0abc", 7);
992 const absl::string_view e;
993 EXPECT_TRUE(a.ends_with(a));
994 EXPECT_TRUE(a.ends_with('r'));
995 EXPECT_TRUE(a.ends_with("bar"));
996 EXPECT_TRUE(a.ends_with(e));
997 EXPECT_TRUE(b.ends_with(b));
998 EXPECT_TRUE(b.ends_with('c'));
999 EXPECT_TRUE(b.ends_with(e));
1000 EXPECT_TRUE(e.ends_with(""));
1001 EXPECT_FALSE(a.ends_with(b));
1002 EXPECT_FALSE(b.ends_with(a));
1003 EXPECT_FALSE(e.ends_with(a));
1004 EXPECT_FALSE(a.ends_with('f'));
1005 EXPECT_FALSE(a.ends_with('\0'));
1006 EXPECT_FALSE(e.ends_with('r'));
1007 EXPECT_FALSE(e.ends_with('\0'));
1008
1009 // Test that constexpr compiles.
1010 constexpr absl::string_view kFooBar("foobar");
1011 constexpr absl::string_view kFoo("foo");
1012 constexpr absl::string_view kBar("bar");
1013 constexpr bool k1 = kFooBar.ends_with(kFoo);
1014 EXPECT_FALSE(k1);
1015 constexpr bool k2 = kFooBar.ends_with(kBar);
1016 EXPECT_TRUE(k2);
1017 constexpr bool k3 = kFooBar.ends_with('r');
1018 EXPECT_TRUE(k3);
1019 constexpr bool k4 = kFooBar.ends_with("ar");
1020 EXPECT_TRUE(k4);
1021 }
1022 #endif // ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
1023
1024 struct MyCharAlloc : std::allocator<char> {};
1025
TEST(StringViewTest,ExplicitConversionOperator)1026 TEST(StringViewTest, ExplicitConversionOperator) {
1027 absl::string_view sp = "hi";
1028 EXPECT_EQ(sp, std::string(sp));
1029 }
1030
TEST(StringViewTest,NullSafeStringView)1031 TEST(StringViewTest, NullSafeStringView) {
1032 {
1033 absl::string_view s = absl::NullSafeStringView(nullptr);
1034 EXPECT_EQ(nullptr, s.data());
1035 EXPECT_EQ(0u, s.size());
1036 EXPECT_EQ(absl::string_view(), s);
1037 }
1038 {
1039 static const char kHi[] = "hi";
1040 absl::string_view s = absl::NullSafeStringView(kHi);
1041 EXPECT_EQ(kHi, s.data());
1042 EXPECT_EQ(strlen(kHi), s.size());
1043 EXPECT_EQ(absl::string_view("hi"), s);
1044 }
1045 }
1046
TEST(StringViewTest,ConstexprNullSafeStringView)1047 TEST(StringViewTest, ConstexprNullSafeStringView) {
1048 {
1049 constexpr absl::string_view s = absl::NullSafeStringView(nullptr);
1050 EXPECT_EQ(nullptr, s.data());
1051 EXPECT_EQ(0u, s.size());
1052 EXPECT_EQ(absl::string_view(), s);
1053 }
1054 #if !defined(_MSC_VER) || _MSC_VER >= 1910
1055 // MSVC 2017+ is required for good constexpr string_view support.
1056 // See the implementation of `absl::string_view::StrlenInternal()`.
1057 {
1058 static constexpr char kHi[] = "hi";
1059 absl::string_view s = absl::NullSafeStringView(kHi);
1060 EXPECT_EQ(kHi, s.data());
1061 EXPECT_EQ(strlen(kHi), s.size());
1062 EXPECT_EQ(absl::string_view("hi"), s);
1063 }
1064 {
1065 constexpr absl::string_view s = absl::NullSafeStringView("hello");
1066 EXPECT_EQ(s.size(), 5u);
1067 EXPECT_EQ("hello", s);
1068 }
1069 #endif
1070 }
1071
TEST(StringViewTest,ConstexprCompiles)1072 TEST(StringViewTest, ConstexprCompiles) {
1073 constexpr absl::string_view sp;
1074 #ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
1075 constexpr absl::string_view cstr(nullptr);
1076 #endif
1077 constexpr absl::string_view cstr_len("cstr", 4);
1078
1079 #if defined(ABSL_USES_STD_STRING_VIEW)
1080 // In libstdc++ (as of 7.2), `std::string_view::string_view(const char*)`
1081 // calls `std::char_traits<char>::length(const char*)` to get the string
1082 // length, but it is not marked constexpr yet. See GCC bug:
1083 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78156
1084 // Also, there is a LWG issue that adds constexpr to length() which was just
1085 // resolved 2017-06-02. See
1086 // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2232
1087 // TODO(zhangxy): Update the condition when libstdc++ adopts the constexpr
1088 // length().
1089 #if !defined(__GLIBCXX__)
1090 #define ABSL_HAVE_CONSTEXPR_STRING_VIEW_FROM_CSTR 1
1091 #endif // !__GLIBCXX__
1092
1093 #else // ABSL_USES_STD_STRING_VIEW
1094
1095 // This duplicates the check for __builtin_strlen in the header.
1096 #if ABSL_HAVE_BUILTIN(__builtin_strlen) || \
1097 (defined(__GNUC__) && !defined(__clang__))
1098 #define ABSL_HAVE_CONSTEXPR_STRING_VIEW_FROM_CSTR 1
1099 #elif defined(__GNUC__) // GCC or clang
1100 #error GCC/clang should have constexpr string_view.
1101 #endif
1102
1103 // MSVC 2017+ should be able to construct a constexpr string_view from a cstr.
1104 #if defined(_MSC_VER) && _MSC_VER >= 1910
1105 #define ABSL_HAVE_CONSTEXPR_STRING_VIEW_FROM_CSTR 1
1106 #endif
1107
1108 #endif // ABSL_USES_STD_STRING_VIEW
1109
1110 #ifdef ABSL_HAVE_CONSTEXPR_STRING_VIEW_FROM_CSTR
1111 constexpr absl::string_view cstr_strlen("foo");
1112 EXPECT_EQ(cstr_strlen.length(), 3u);
1113 constexpr absl::string_view cstr_strlen2 = "bar";
1114 EXPECT_EQ(cstr_strlen2, "bar");
1115
1116 #if ABSL_HAVE_BUILTIN(__builtin_memcmp) || \
1117 (defined(__GNUC__) && !defined(__clang__))
1118 #define ABSL_HAVE_CONSTEXPR_STRING_VIEW_COMPARISON 1
1119 #endif
1120 #ifdef ABSL_HAVE_CONSTEXPR_STRING_VIEW_COMPARISON
1121 constexpr absl::string_view foo = "foo";
1122 constexpr absl::string_view bar = "bar";
1123 constexpr bool foo_eq_bar = foo == bar;
1124 constexpr bool foo_ne_bar = foo != bar;
1125 constexpr bool foo_lt_bar = foo < bar;
1126 constexpr bool foo_le_bar = foo <= bar;
1127 constexpr bool foo_gt_bar = foo > bar;
1128 constexpr bool foo_ge_bar = foo >= bar;
1129 constexpr int foo_compare_bar = foo.compare(bar);
1130 EXPECT_FALSE(foo_eq_bar);
1131 EXPECT_TRUE(foo_ne_bar);
1132 EXPECT_FALSE(foo_lt_bar);
1133 EXPECT_FALSE(foo_le_bar);
1134 EXPECT_TRUE(foo_gt_bar);
1135 EXPECT_TRUE(foo_ge_bar);
1136 EXPECT_GT(foo_compare_bar, 0);
1137 #endif
1138 #endif
1139
1140 #if !defined(__clang__) || 3 < __clang_major__ || \
1141 (3 == __clang_major__ && 4 < __clang_minor__)
1142 // older clang versions (< 3.5) complain that:
1143 // "cannot perform pointer arithmetic on null pointer"
1144 constexpr absl::string_view::iterator const_begin_empty = sp.begin();
1145 constexpr absl::string_view::iterator const_end_empty = sp.end();
1146 EXPECT_EQ(const_begin_empty, const_end_empty);
1147
1148 #ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
1149 constexpr absl::string_view::iterator const_begin_nullptr = cstr.begin();
1150 constexpr absl::string_view::iterator const_end_nullptr = cstr.end();
1151 EXPECT_EQ(const_begin_nullptr, const_end_nullptr);
1152 #endif // ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
1153 #endif // !defined(__clang__) || ...
1154
1155 constexpr absl::string_view::iterator const_begin = cstr_len.begin();
1156 constexpr absl::string_view::iterator const_end = cstr_len.end();
1157 constexpr absl::string_view::size_type const_size = cstr_len.size();
1158 constexpr absl::string_view::size_type const_length = cstr_len.length();
1159 static_assert(const_begin + const_size == const_end,
1160 "pointer arithmetic check");
1161 static_assert(const_begin + const_length == const_end,
1162 "pointer arithmetic check");
1163 #ifndef _MSC_VER
1164 // MSVC has bugs doing constexpr pointer arithmetic.
1165 // https://developercommunity.visualstudio.com/content/problem/482192/bad-pointer-arithmetic-in-constepxr-2019-rc1-svc1.html
1166 EXPECT_EQ(const_begin + const_size, const_end);
1167 EXPECT_EQ(const_begin + const_length, const_end);
1168 #endif
1169
1170 constexpr bool isempty = sp.empty();
1171 EXPECT_TRUE(isempty);
1172
1173 constexpr const char c = cstr_len[2];
1174 EXPECT_EQ(c, 't');
1175
1176 constexpr const char cfront = cstr_len.front();
1177 constexpr const char cback = cstr_len.back();
1178 EXPECT_EQ(cfront, 'c');
1179 EXPECT_EQ(cback, 'r');
1180
1181 constexpr const char* np = sp.data();
1182 constexpr const char* cstr_ptr = cstr_len.data();
1183 EXPECT_EQ(np, nullptr);
1184 EXPECT_NE(cstr_ptr, nullptr);
1185
1186 constexpr size_t sp_npos = sp.npos;
1187 EXPECT_EQ(sp_npos, static_cast<size_t>(-1));
1188 }
1189
ConstexprMethodsHelper()1190 constexpr char ConstexprMethodsHelper() {
1191 #if defined(__cplusplus) && __cplusplus >= 201402L
1192 absl::string_view str("123", 3);
1193 str.remove_prefix(1);
1194 str.remove_suffix(1);
1195 absl::string_view bar;
1196 str.swap(bar);
1197 return bar.front();
1198 #else
1199 return '2';
1200 #endif
1201 }
1202
TEST(StringViewTest,ConstexprMethods)1203 TEST(StringViewTest, ConstexprMethods) {
1204 // remove_prefix, remove_suffix, swap
1205 static_assert(ConstexprMethodsHelper() == '2', "");
1206
1207 // substr
1208 constexpr absl::string_view foobar("foobar", 6);
1209 constexpr absl::string_view foo = foobar.substr(0, 3);
1210 constexpr absl::string_view bar = foobar.substr(3);
1211 EXPECT_EQ(foo, "foo");
1212 EXPECT_EQ(bar, "bar");
1213 }
1214
TEST(StringViewTest,Noexcept)1215 TEST(StringViewTest, Noexcept) {
1216 EXPECT_TRUE((std::is_nothrow_constructible<absl::string_view,
1217 const std::string&>::value));
1218 EXPECT_TRUE((std::is_nothrow_constructible<absl::string_view,
1219 const std::string&>::value));
1220 EXPECT_TRUE(std::is_nothrow_constructible<absl::string_view>::value);
1221 constexpr absl::string_view sp;
1222 EXPECT_TRUE(noexcept(sp.begin()));
1223 EXPECT_TRUE(noexcept(sp.end()));
1224 EXPECT_TRUE(noexcept(sp.cbegin()));
1225 EXPECT_TRUE(noexcept(sp.cend()));
1226 EXPECT_TRUE(noexcept(sp.rbegin()));
1227 EXPECT_TRUE(noexcept(sp.rend()));
1228 EXPECT_TRUE(noexcept(sp.crbegin()));
1229 EXPECT_TRUE(noexcept(sp.crend()));
1230 EXPECT_TRUE(noexcept(sp.size()));
1231 EXPECT_TRUE(noexcept(sp.length()));
1232 EXPECT_TRUE(noexcept(sp.empty()));
1233 EXPECT_TRUE(noexcept(sp.data()));
1234 EXPECT_TRUE(noexcept(sp.compare(sp)));
1235 EXPECT_TRUE(noexcept(sp.find(sp)));
1236 EXPECT_TRUE(noexcept(sp.find('f')));
1237 EXPECT_TRUE(noexcept(sp.rfind(sp)));
1238 EXPECT_TRUE(noexcept(sp.rfind('f')));
1239 EXPECT_TRUE(noexcept(sp.find_first_of(sp)));
1240 EXPECT_TRUE(noexcept(sp.find_first_of('f')));
1241 EXPECT_TRUE(noexcept(sp.find_last_of(sp)));
1242 EXPECT_TRUE(noexcept(sp.find_last_of('f')));
1243 EXPECT_TRUE(noexcept(sp.find_first_not_of(sp)));
1244 EXPECT_TRUE(noexcept(sp.find_first_not_of('f')));
1245 EXPECT_TRUE(noexcept(sp.find_last_not_of(sp)));
1246 EXPECT_TRUE(noexcept(sp.find_last_not_of('f')));
1247 }
1248
TEST(StringViewTest,BoundsCheck)1249 TEST(StringViewTest, BoundsCheck) {
1250 #ifndef ABSL_USES_STD_STRING_VIEW
1251 #if !defined(NDEBUG) || ABSL_OPTION_HARDENED
1252 // Abseil's string_view implementation has bounds-checking in debug mode.
1253 absl::string_view h = "hello";
1254 ABSL_EXPECT_DEATH_IF_SUPPORTED(h[5], "");
1255 ABSL_EXPECT_DEATH_IF_SUPPORTED(h[static_cast<size_t>(-1)], "");
1256 #endif
1257 #endif
1258 }
1259
TEST(ComparisonOpsTest,StringCompareNotAmbiguous)1260 TEST(ComparisonOpsTest, StringCompareNotAmbiguous) {
1261 EXPECT_EQ("hello", std::string("hello"));
1262 EXPECT_LT("hello", std::string("world"));
1263 }
1264
TEST(ComparisonOpsTest,HeterogeneousStringViewEquals)1265 TEST(ComparisonOpsTest, HeterogeneousStringViewEquals) {
1266 EXPECT_EQ(absl::string_view("hello"), std::string("hello"));
1267 EXPECT_EQ("hello", absl::string_view("hello"));
1268 }
1269
TEST(FindOneCharTest,EdgeCases)1270 TEST(FindOneCharTest, EdgeCases) {
1271 absl::string_view a("xxyyyxx");
1272
1273 // Set a = "xyyyx".
1274 a.remove_prefix(1);
1275 a.remove_suffix(1);
1276
1277 EXPECT_EQ(0u, a.find('x'));
1278 EXPECT_EQ(0u, a.find('x', 0));
1279 EXPECT_EQ(4u, a.find('x', 1));
1280 EXPECT_EQ(4u, a.find('x', 4));
1281 EXPECT_EQ(absl::string_view::npos, a.find('x', 5));
1282
1283 EXPECT_EQ(4u, a.rfind('x'));
1284 EXPECT_EQ(4u, a.rfind('x', 5));
1285 EXPECT_EQ(4u, a.rfind('x', 4));
1286 EXPECT_EQ(0u, a.rfind('x', 3));
1287 EXPECT_EQ(0u, a.rfind('x', 0));
1288
1289 // Set a = "yyy".
1290 a.remove_prefix(1);
1291 a.remove_suffix(1);
1292
1293 EXPECT_EQ(absl::string_view::npos, a.find('x'));
1294 EXPECT_EQ(absl::string_view::npos, a.rfind('x'));
1295 }
1296
1297 #ifndef ABSL_HAVE_THREAD_SANITIZER // Allocates too much memory for tsan.
TEST(HugeStringView,TwoPointTwoGB)1298 TEST(HugeStringView, TwoPointTwoGB) {
1299 if (sizeof(size_t) <= 4)
1300 return;
1301 // Try a huge string piece.
1302 const size_t size = size_t{2200} * 1000 * 1000;
1303 std::string s(size, 'a');
1304 absl::string_view sp(s);
1305 EXPECT_EQ(size, sp.length());
1306 sp.remove_prefix(1);
1307 EXPECT_EQ(size - 1, sp.length());
1308 sp.remove_suffix(2);
1309 EXPECT_EQ(size - 1 - 2, sp.length());
1310 }
1311 #endif // ABSL_HAVE_THREAD_SANITIZER
1312
1313 #if !defined(NDEBUG) && !defined(ABSL_USES_STD_STRING_VIEW)
TEST(NonNegativeLenTest,NonNegativeLen)1314 TEST(NonNegativeLenTest, NonNegativeLen) {
1315 ABSL_EXPECT_DEATH_IF_SUPPORTED(
1316 absl::string_view("xyz", static_cast<size_t>(-1)), "len <= kMaxSize");
1317 }
1318
TEST(LenExceedsMaxSizeTest,LenExceedsMaxSize)1319 TEST(LenExceedsMaxSizeTest, LenExceedsMaxSize) {
1320 auto max_size = absl::string_view().max_size();
1321
1322 // This should construct ok (although the view itself is obviously invalid).
1323 absl::string_view ok_view("", max_size);
1324
1325 // Adding one to the max should trigger an assertion.
1326 ABSL_EXPECT_DEATH_IF_SUPPORTED(absl::string_view("", max_size + 1),
1327 "len <= kMaxSize");
1328 }
1329 #endif // !defined(NDEBUG) && !defined(ABSL_USES_STD_STRING_VIEW)
1330
1331 class StringViewStreamTest : public ::testing::Test {
1332 public:
1333 // Set negative 'width' for right justification.
1334 template <typename T>
Pad(const T & s,int width,char fill=0)1335 std::string Pad(const T& s, int width, char fill = 0) {
1336 std::ostringstream oss;
1337 if (fill != 0) {
1338 oss << std::setfill(fill);
1339 }
1340 if (width < 0) {
1341 width = -width;
1342 oss << std::right;
1343 }
1344 oss << std::setw(width) << s;
1345 return oss.str();
1346 }
1347 };
1348
TEST_F(StringViewStreamTest,Padding)1349 TEST_F(StringViewStreamTest, Padding) {
1350 std::string s("hello");
1351 absl::string_view sp(s);
1352 for (int w = -64; w < 64; ++w) {
1353 SCOPED_TRACE(w);
1354 EXPECT_EQ(Pad(s, w), Pad(sp, w));
1355 }
1356 for (int w = -64; w < 64; ++w) {
1357 SCOPED_TRACE(w);
1358 EXPECT_EQ(Pad(s, w, '#'), Pad(sp, w, '#'));
1359 }
1360 }
1361
TEST_F(StringViewStreamTest,ResetsWidth)1362 TEST_F(StringViewStreamTest, ResetsWidth) {
1363 // Width should reset after one formatted write.
1364 // If we weren't resetting width after formatting the string_view,
1365 // we'd have width=5 carrying over to the printing of the "]",
1366 // creating "[###hi####]".
1367 std::string s = "hi";
1368 absl::string_view sp = s;
1369 {
1370 std::ostringstream oss;
1371 oss << "[" << std::setfill('#') << std::setw(5) << s << "]";
1372 ASSERT_EQ("[###hi]", oss.str());
1373 }
1374 {
1375 std::ostringstream oss;
1376 oss << "[" << std::setfill('#') << std::setw(5) << sp << "]";
1377 EXPECT_EQ("[###hi]", oss.str());
1378 }
1379 }
1380
1381 } // namespace
1382