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