1 | #include <c10/util/string_view.h> |
2 | |
3 | #include <gmock/gmock.h> |
4 | |
5 | using c10::string_view; |
6 | |
7 | namespace { |
8 | namespace testutils { |
9 | constexpr bool string_equal(const char* lhs, const char* rhs, size_t size) { |
10 | return (size == 0) ? true |
11 | : (*lhs != *rhs) ? false |
12 | : string_equal(lhs + 1, rhs + 1, size - 1); |
13 | } |
14 | static_assert(string_equal("hi" , "hi" , 2), "" ); |
15 | static_assert(string_equal("" , "" , 0), "" ); |
16 | static_assert(string_equal("hi" , "hi2" , 2), "" ); |
17 | static_assert(string_equal("hi2" , "hi" , 2), "" ); |
18 | static_assert(!string_equal("hi" , "hi2" , 3), "" ); |
19 | static_assert(!string_equal("hi2" , "hi" , 3), "" ); |
20 | static_assert(!string_equal("hi" , "ha" , 2), "" ); |
21 | |
22 | template <class Exception, class Functor> |
23 | inline void expectThrows(Functor&& functor, const char* expectMessageContains) { |
24 | try { |
25 | std::forward<Functor>(functor)(); |
26 | } catch (const Exception& e) { |
27 | EXPECT_THAT(e.what(), testing::HasSubstr(expectMessageContains)); |
28 | return; |
29 | } |
30 | ADD_FAILURE() << "Expected to throw exception containing \"" |
31 | << expectMessageContains << "\" but didn't throw" ; |
32 | } |
33 | } // namespace testutils |
34 | |
35 | using testutils::expectThrows; |
36 | using testutils::string_equal; |
37 | |
38 | namespace test_typedefs { |
39 | static_assert(std::is_same<char, string_view::value_type>::value, "" ); |
40 | static_assert(std::is_same<char*, string_view::pointer>::value, "" ); |
41 | static_assert(std::is_same<const char*, string_view::const_pointer>::value, "" ); |
42 | static_assert(std::is_same<char&, string_view::reference>::value, "" ); |
43 | static_assert( |
44 | std::is_same<const char&, string_view::const_reference>::value, |
45 | "" ); |
46 | static_assert(std::is_same<std::size_t, string_view::size_type>::value, "" ); |
47 | static_assert( |
48 | std::is_same<std::ptrdiff_t, string_view::difference_type>::value, |
49 | "" ); |
50 | } // namespace test_typedefs |
51 | |
52 | namespace test_default_constructor { |
53 | static_assert(string_view().size() == 0, "" ); |
54 | static_assert(string_view().data() == nullptr, "" ); |
55 | static_assert(string_view() == string_view("" ), "" ); |
56 | } // namespace test_default_constructor |
57 | |
58 | namespace test_constchar_constructor { |
59 | static_assert(string_view("" ).size() == 0, "" ); |
60 | constexpr string_view hello = "hello" ; |
61 | static_assert(5 == hello.size(), "" ); |
62 | static_assert(string_equal("hello" , hello.data(), hello.size()), "" ); |
63 | } // namespace test_constchar_constructor |
64 | |
65 | namespace test_sized_constructor { |
66 | static_assert(string_view("" , 0).size() == 0, "" ); |
67 | constexpr string_view hell("hello" , 4); |
68 | static_assert(4 == hell.size(), "" ); |
69 | static_assert(string_equal("hell" , hell.data(), hell.size()), "" ); |
70 | } // namespace test_sized_constructor |
71 | |
72 | namespace test_string_constructor { |
73 | void test_conversion_is_implicit(string_view a) {} |
74 | TEST(StringViewTest, testStringConstructor) { |
75 | std::string empty; |
76 | EXPECT_EQ(0, string_view(empty).size()); |
77 | std::string hello_str = "hello" ; |
78 | string_view hello_sv = hello_str; |
79 | EXPECT_EQ(5, hello_sv.size()); |
80 | EXPECT_TRUE(string_equal("hello" , hello_sv.data(), hello_sv.size())); |
81 | |
82 | test_conversion_is_implicit(hello_str); |
83 | } |
84 | } // namespace test_string_constructor |
85 | |
86 | namespace test_conversion_to_string { |
87 | TEST(StringViewTest, testConversionToString) { |
88 | string_view empty; |
89 | EXPECT_EQ(0, std::string(empty).size()); |
90 | string_view hello_sv = "hello" ; |
91 | std::string hello_str(hello_sv); |
92 | EXPECT_EQ(5, hello_str.size()); |
93 | EXPECT_EQ(std::string("hello" ), hello_str); |
94 | } |
95 | } // namespace test_conversion_to_string |
96 | |
97 | namespace test_copy_constructor { |
98 | constexpr string_view hello = "hello" ; |
99 | constexpr string_view copy = hello; |
100 | static_assert(5 == copy.size(), "" ); |
101 | static_assert(string_equal("hello" , copy.data(), copy.size()), "" ); |
102 | } // namespace test_copy_constructor |
103 | |
104 | namespace test_copy_assignment { |
105 | constexpr string_view assign(string_view value) { |
106 | string_view result = "temporary_content" ; |
107 | result = value; // this is the assignment we're testing |
108 | return result; |
109 | } |
110 | TEST(StringViewTest, testCopyAssignment) { |
111 | #if defined(__cpp_constexpr) && __cpp_constexpr >= 201304 |
112 | { |
113 | constexpr string_view hello = assign("hello" ); |
114 | static_assert(5 == hello.size(), "" ); |
115 | static_assert(string_equal("hello" , hello.data(), hello.size()), "" ); |
116 | |
117 | static_assert(5 == (string_view() = "hello" ).size(), "" ); |
118 | static_assert( |
119 | string_equal("hello" , (string_view() = "hello" ).data(), 5), "" ); |
120 | } |
121 | #endif |
122 | const string_view hello = assign("hello" ); |
123 | EXPECT_EQ(5, hello.size()); |
124 | EXPECT_EQ("hello" , hello); |
125 | EXPECT_EQ(5, (string_view() = "hello" ).size()); |
126 | EXPECT_EQ("hello" , (string_view() = "hello" )); |
127 | } |
128 | |
129 | } // namespace test_copy_assignment |
130 | |
131 | namespace test_iterators { |
132 | static_assert('h' == *string_view("hello" ).begin(), "" ); |
133 | static_assert('h' == *string_view("hello" ).cbegin(), "" ); |
134 | static_assert('h' == *begin(string_view("hello" )), "" ); |
135 | static_assert('o' == *(string_view("hello" ).end() - 1), "" ); |
136 | static_assert('o' == *(string_view("hello" ).cend() - 1), "" ); |
137 | static_assert('o' == *(end(string_view("hello" )) - 1), "" ); |
138 | static_assert('o' == *string_view("hello" ).rbegin(), "" ); |
139 | static_assert('o' == *string_view("hello" ).crbegin(), "" ); |
140 | static_assert('h' == *(string_view("hello" ).rend() - 1), "" ); |
141 | static_assert('h' == *(string_view("hello" ).crend() - 1), "" ); |
142 | } // namespace test_iterators |
143 | |
144 | namespace test_forward_iteration { |
145 | constexpr string_view hello = "hello" ; |
146 | static_assert('h' == *(hello.begin() + 0), "" ); |
147 | static_assert('e' == *(hello.begin() + 1), "" ); |
148 | static_assert('l' == *(hello.begin() + 2), "" ); |
149 | static_assert('l' == *(hello.begin() + 3), "" ); |
150 | static_assert('o' == *(hello.begin() + 4), "" ); |
151 | static_assert(hello.end() == hello.begin() + 5, "" ); |
152 | } // namespace test_forward_iteration |
153 | |
154 | namespace test_reverse_iteration { |
155 | constexpr string_view hello = "hello" ; |
156 | static_assert('o' == *(hello.rbegin() + 0), "" ); |
157 | static_assert('l' == *(hello.rbegin() + 1), "" ); |
158 | static_assert('l' == *(hello.rbegin() + 2), "" ); |
159 | static_assert('e' == *(hello.rbegin() + 3), "" ); |
160 | static_assert('h' == *(hello.rbegin() + 4), "" ); |
161 | static_assert(hello.rend() == hello.rbegin() + 5, "" ); |
162 | } // namespace test_reverse_iteration |
163 | |
164 | namespace test_random_access { |
165 | constexpr string_view hello = "hello" ; |
166 | static_assert('h' == hello[0], "" ); |
167 | static_assert('e' == hello[1], "" ); |
168 | static_assert('l' == hello[2], "" ); |
169 | static_assert('l' == hello[3], "" ); |
170 | static_assert('o' == hello[4], "" ); |
171 | |
172 | static_assert('h' == hello.at(0), "" ); |
173 | static_assert('e' == hello.at(1), "" ); |
174 | static_assert('l' == hello.at(2), "" ); |
175 | static_assert('l' == hello.at(3), "" ); |
176 | static_assert('o' == hello.at(4), "" ); |
177 | |
178 | TEST(StringViewTest, whenCallingAccessOperatorOutOfRange_thenThrows) { |
179 | expectThrows<std::out_of_range>( |
180 | [] { string_view("" ).at(1); }, |
181 | "string_view::operator[] or string_view::at() out of range. Index: 1, size: 0" ); |
182 | |
183 | expectThrows<std::out_of_range>( |
184 | [] { string_view("hello" ).at(5); }, |
185 | "string_view::operator[] or string_view::at() out of range. Index: 5, size: 5" ); |
186 | |
187 | expectThrows<std::out_of_range>( |
188 | [] { string_view("hello" ).at(100); }, |
189 | "string_view::operator[] or string_view::at() out of range. Index: 100, size: 5" ); |
190 | |
191 | expectThrows<std::out_of_range>( |
192 | [] { string_view("hello" ).at(string_view::npos); }, |
193 | "string_view::operator[] or string_view::at() out of range. Index: 18446744073709551615, size: 5" ); |
194 | } |
195 | } // namespace test_random_access |
196 | |
197 | namespace test_front_back { |
198 | static_assert('h' == string_view("hello" ).front(), "" ); |
199 | static_assert('o' == string_view("hello" ).back(), "" ); |
200 | } // namespace test_front_back |
201 | |
202 | namespace test_data { |
203 | static_assert(string_equal("hello" , string_view("hello" ).data(), 5), "" ); |
204 | } // namespace test_data |
205 | |
206 | namespace test_size_length { |
207 | static_assert(0 == string_view("" ).size(), "" ); |
208 | static_assert(5 == string_view("hello" ).size(), "" ); |
209 | |
210 | static_assert(0 == string_view("" ).length(), "" ); |
211 | static_assert(5 == string_view("hello" ).length(), "" ); |
212 | } // namespace test_size_length |
213 | |
214 | namespace test_empty { |
215 | static_assert(string_view().empty(), "" ); |
216 | static_assert(string_view("" ).empty(), "" ); |
217 | static_assert(!string_view("hello" ).empty(), "" ); |
218 | } // namespace test_empty |
219 | |
220 | namespace test_remove_prefix { |
221 | constexpr string_view remove_prefix(string_view input, size_t len) { |
222 | input.remove_prefix(len); |
223 | return input; |
224 | } |
225 | |
226 | TEST(StringViewTest, whenRemovingValidPrefix_thenWorks) { |
227 | static_assert( |
228 | remove_prefix(string_view("hello" ), 0) == string_view("hello" ), "" ); |
229 | static_assert( |
230 | remove_prefix(string_view("hello" ), 1) == string_view("ello" ), "" ); |
231 | static_assert(remove_prefix(string_view("hello" ), 5) == string_view("" ), "" ); |
232 | |
233 | EXPECT_EQ(remove_prefix(string_view("hello" ), 0), string_view("hello" )); |
234 | EXPECT_EQ(remove_prefix(string_view("hello" ), 1), string_view("ello" )); |
235 | EXPECT_EQ(remove_prefix(string_view("hello" ), 5), string_view("" )); |
236 | } |
237 | |
238 | TEST(StringViewTest, whenRemovingTooLargePrefix_thenThrows) { |
239 | expectThrows<std::out_of_range>( |
240 | [] { remove_prefix(string_view("hello" ), 6); }, |
241 | "basic_string_view::remove_prefix: out of range. PrefixLength: 6, size: 5" ); |
242 | } |
243 | } // namespace test_remove_prefix |
244 | |
245 | namespace test_remove_suffix { |
246 | constexpr string_view remove_suffix(string_view input, size_t len) { |
247 | input.remove_suffix(len); |
248 | return input; |
249 | } |
250 | |
251 | TEST(StringViewTest, whenRemovingValidSuffix_thenWorks) { |
252 | static_assert( |
253 | remove_suffix(string_view("hello" ), 0) == string_view("hello" ), "" ); |
254 | static_assert( |
255 | remove_suffix(string_view("hello" ), 1) == string_view("hell" ), "" ); |
256 | static_assert(remove_suffix(string_view("hello" ), 5) == string_view("" ), "" ); |
257 | |
258 | EXPECT_EQ(remove_suffix(string_view("hello" ), 0), string_view("hello" )); |
259 | EXPECT_EQ(remove_suffix(string_view("hello" ), 1), string_view("hell" )); |
260 | EXPECT_EQ(remove_suffix(string_view("hello" ), 5), string_view("" )); |
261 | } |
262 | |
263 | TEST(StringViewTest, whenRemovingTooLargeSuffix_thenThrows) { |
264 | expectThrows<std::out_of_range>( |
265 | [] { remove_suffix(string_view("hello" ), 6); }, |
266 | "basic_string_view::remove_suffix: out of range. SuffixLength: 6, size: 5" ); |
267 | } |
268 | } // namespace test_remove_suffix |
269 | |
270 | namespace test_swap_function { |
271 | constexpr std::pair<string_view, string_view> get() { |
272 | string_view first = "first" ; |
273 | string_view second = "second" ; |
274 | swap(first, second); |
275 | return std::make_pair(first, second); |
276 | } |
277 | TEST(StringViewTest, testSwapFunction) { |
278 | static_assert(string_view("second" ) == get().first, "" ); |
279 | static_assert(string_view("first" ) == get().second, "" ); |
280 | |
281 | EXPECT_EQ(string_view("second" ), get().first); |
282 | EXPECT_EQ(string_view("first" ), get().second); |
283 | } |
284 | } // namespace test_swap_function |
285 | |
286 | namespace test_swap_method { |
287 | constexpr std::pair<string_view, string_view> get() { |
288 | string_view first = "first" ; |
289 | string_view second = "second" ; |
290 | first.swap(second); |
291 | return std::make_pair(first, second); |
292 | } |
293 | TEST(StringViewTest, testSwapMethod) { |
294 | static_assert(string_view("second" ) == get().first, "" ); |
295 | static_assert(string_view("first" ) == get().second, "" ); |
296 | |
297 | EXPECT_EQ(string_view("second" ), get().first); |
298 | EXPECT_EQ(string_view("first" ), get().second); |
299 | } |
300 | } // namespace test_swap_method |
301 | |
302 | namespace test_copy { |
303 | TEST(StringViewTest, whenCopyingFullStringView_thenDestinationHasCorrectData) { |
304 | string_view data = "hello" ; |
305 | // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays) |
306 | char result[5]; |
307 | size_t num_copied = data.copy(result, 5); |
308 | EXPECT_EQ(5, num_copied); |
309 | EXPECT_TRUE(string_equal("hello" , result, 5)); |
310 | } |
311 | |
312 | TEST(StringViewTest, whenCopyingSubstr_thenDestinationHasCorrectData) { |
313 | string_view data = "hello" ; |
314 | // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) |
315 | char result[2]; |
316 | size_t num_copied = data.copy(result, 2, 2); |
317 | EXPECT_EQ(2, num_copied); |
318 | EXPECT_TRUE(string_equal("ll" , result, 2)); |
319 | } |
320 | |
321 | TEST(StringViewTest, whenCopyingTooMuch_thenJustCopiesLess) { |
322 | string_view data = "hello" ; |
323 | // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays) |
324 | char result[100]; |
325 | size_t num_copied = data.copy(result, 100, 2); |
326 | EXPECT_EQ(3, num_copied); |
327 | EXPECT_TRUE(string_equal("llo" , result, 3)); |
328 | } |
329 | |
330 | TEST(StringViewTest, whenCopyingJustAtRange_thenDoesntCrash) { |
331 | string_view data = "hello" ; |
332 | // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) |
333 | char result[1]; |
334 | size_t num_copied = data.copy(result, 2, 5); |
335 | EXPECT_EQ(0, num_copied); |
336 | } |
337 | |
338 | TEST(StringViewTest, whenCopyingOutOfRange_thenThrows) { |
339 | string_view data = "hello" ; |
340 | // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) |
341 | char result[2]; |
342 | expectThrows<std::out_of_range>( |
343 | // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays) |
344 | [&] { data.copy(result, 2, 6); }, |
345 | "basic_string_view::copy: out of range. Index: 6, size: 5" ); |
346 | } |
347 | } // namespace test_copy |
348 | |
349 | namespace test_substr { |
350 | static_assert(string_view("" ).substr() == string_view("" ), "" ); |
351 | static_assert(string_view("" ).substr(0) == string_view("" ), "" ); |
352 | static_assert(string_view("" ).substr(0, 0) == string_view("" ), "" ); |
353 | |
354 | static_assert(string_view("hello" ).substr() == string_view("hello" ), "" ); |
355 | static_assert(string_view("hello" ).substr(0) == string_view("hello" ), "" ); |
356 | static_assert(string_view("hello" ).substr(1) == string_view("ello" ), "" ); |
357 | static_assert(string_view("hello" ).substr(5) == string_view("" ), "" ); |
358 | |
359 | static_assert(string_view("hello" ).substr(0, 0) == string_view("" ), "" ); |
360 | static_assert(string_view("hello" ).substr(0, 2) == string_view("he" ), "" ); |
361 | static_assert(string_view("hello" ).substr(1, 2) == string_view("el" ), "" ); |
362 | static_assert(string_view("hello" ).substr(4, 1) == string_view("o" ), "" ); |
363 | |
364 | static_assert(string_view("hello" ).substr(0, 100) == string_view("hello" ), "" ); |
365 | static_assert(string_view("hello" ).substr(1, 100) == string_view("ello" ), "" ); |
366 | static_assert(string_view("hello" ).substr(5, 100) == string_view("" ), "" ); |
367 | |
368 | TEST(StringViewTest, whenCallingSubstrWithPosOutOfRange_thenThrows) { |
369 | expectThrows<std::out_of_range>( |
370 | [] { string_view("hello" ).substr(6); }, |
371 | "basic_string_view::substr parameter out of bounds. Index: 6, size: 5" ); |
372 | |
373 | expectThrows<std::out_of_range>( |
374 | [] { string_view("hello" ).substr(6, 0); }, |
375 | "basic_string_view::substr parameter out of bounds. Index: 6, size: 5" ); |
376 | } |
377 | } // namespace test_substr |
378 | |
379 | namespace test_compare_overload1 { |
380 | static_assert(0 == string_view("" ).compare(string_view("" )), "" ); |
381 | static_assert(0 == string_view("a" ).compare(string_view("a" )), "" ); |
382 | static_assert(0 == string_view("hello" ).compare(string_view("hello" )), "" ); |
383 | static_assert(0 < string_view("hello" ).compare(string_view("" )), "" ); |
384 | static_assert(0 < string_view("hello" ).compare(string_view("aello" )), "" ); |
385 | static_assert(0 < string_view("hello" ).compare(string_view("a" )), "" ); |
386 | static_assert( |
387 | 0 < string_view("hello" ).compare(string_view("abcdefghijklmno" )), |
388 | "" ); |
389 | static_assert(0 < string_view("hello" ).compare(string_view("hela" )), "" ); |
390 | static_assert(0 < string_view("hello" ).compare(string_view("helao" )), "" ); |
391 | static_assert( |
392 | 0 < string_view("hello" ).compare(string_view("helaobcdefgh" )), |
393 | "" ); |
394 | static_assert(0 < string_view("hello" ).compare(string_view("hell" )), "" ); |
395 | static_assert(0 > string_view("" ).compare(string_view("hello" )), "" ); |
396 | static_assert(0 > string_view("hello" ).compare(string_view("zello" )), "" ); |
397 | static_assert(0 > string_view("hello" ).compare(string_view("z" )), "" ); |
398 | static_assert( |
399 | 0 > string_view("hello" ).compare(string_view("zabcdefghijklmno" )), |
400 | "" ); |
401 | static_assert(0 > string_view("hello" ).compare(string_view("helz" )), "" ); |
402 | static_assert(0 > string_view("hello" ).compare(string_view("helzo" )), "" ); |
403 | static_assert( |
404 | 0 > string_view("hello" ).compare(string_view("helzobcdefgh" )), |
405 | "" ); |
406 | static_assert(0 > string_view("hello" ).compare(string_view("helloa" )), "" ); |
407 | } // namespace test_compare_overload1 |
408 | |
409 | namespace test_compare_overload2 { |
410 | static_assert(0 == string_view("" ).compare(0, 0, string_view("" )), "" ); |
411 | static_assert(0 == string_view("hello" ).compare(2, 2, string_view("ll" )), "" ); |
412 | static_assert(0 < string_view("hello" ).compare(2, 2, string_view("l" )), "" ); |
413 | static_assert(0 > string_view("hello" ).compare(2, 2, string_view("lll" )), "" ); |
414 | static_assert(0 < string_view("hello" ).compare(2, 2, string_view("la" )), "" ); |
415 | static_assert(0 > string_view("hello" ).compare(2, 2, string_view("lz" )), "" ); |
416 | } // namespace test_compare_overload2 |
417 | |
418 | namespace test_compare_overload3 { |
419 | static_assert(0 == string_view("" ).compare(0, 0, string_view("" ), 0, 0), "" ); |
420 | static_assert( |
421 | 0 == string_view("hello" ).compare(2, 2, string_view("hello" ), 2, 2), |
422 | "" ); |
423 | static_assert( |
424 | 0 < string_view("hello" ).compare(2, 2, string_view("hello" ), 2, 1), |
425 | "" ); |
426 | static_assert( |
427 | 0 > string_view("hello" ).compare(2, 2, string_view("hello" ), 2, 3), |
428 | "" ); |
429 | static_assert( |
430 | 0 < string_view("hello" ).compare(2, 2, string_view("hellola" ), 5, 2), |
431 | "" ); |
432 | static_assert( |
433 | 0 > string_view("hello" ).compare(2, 2, string_view("hellolz" ), 5, 2), |
434 | "" ); |
435 | } // namespace test_compare_overload3 |
436 | |
437 | namespace test_compare_overload4 { |
438 | static_assert(0 == string_view("" ).compare("" ), "" ); |
439 | static_assert(0 == string_view("a" ).compare("a" ), "" ); |
440 | static_assert(0 == string_view("hello" ).compare("hello" ), "" ); |
441 | static_assert(0 < string_view("hello" ).compare("" ), "" ); |
442 | static_assert(0 < string_view("hello" ).compare("aello" ), "" ); |
443 | static_assert(0 < string_view("hello" ).compare("a" ), "" ); |
444 | static_assert(0 < string_view("hello" ).compare("abcdefghijklmno" ), "" ); |
445 | static_assert(0 < string_view("hello" ).compare("hela" ), "" ); |
446 | static_assert(0 < string_view("hello" ).compare("helao" ), "" ); |
447 | static_assert(0 < string_view("hello" ).compare("helaobcdefgh" ), "" ); |
448 | static_assert(0 < string_view("hello" ).compare("hell" ), "" ); |
449 | static_assert(0 > string_view("" ).compare("hello" ), "" ); |
450 | static_assert(0 > string_view("hello" ).compare("zello" ), "" ); |
451 | static_assert(0 > string_view("hello" ).compare("z" ), "" ); |
452 | static_assert(0 > string_view("hello" ).compare("zabcdefghijklmno" ), "" ); |
453 | static_assert(0 > string_view("hello" ).compare("helz" ), "" ); |
454 | static_assert(0 > string_view("hello" ).compare("helzo" ), "" ); |
455 | static_assert(0 > string_view("hello" ).compare("helzobcdefgh" ), "" ); |
456 | static_assert(0 > string_view("hello" ).compare("helloa" ), "" ); |
457 | } // namespace test_compare_overload4 |
458 | |
459 | namespace test_compare_overload5 { |
460 | static_assert(0 == string_view("" ).compare(0, 0, "" ), "" ); |
461 | static_assert(0 == string_view("hello" ).compare(2, 2, "ll" ), "" ); |
462 | static_assert(0 < string_view("hello" ).compare(2, 2, "l" ), "" ); |
463 | static_assert(0 > string_view("hello" ).compare(2, 2, "lll" ), "" ); |
464 | static_assert(0 < string_view("hello" ).compare(2, 2, "la" ), "" ); |
465 | static_assert(0 > string_view("hello" ).compare(2, 2, "lz" ), "" ); |
466 | } // namespace test_compare_overload5 |
467 | |
468 | namespace test_compare_overload6 { |
469 | static_assert(0 == string_view("" ).compare(0, 0, "" , 0, 0), "" ); |
470 | static_assert(0 == string_view("hello" ).compare(2, 2, "hello" , 2, 2), "" ); |
471 | static_assert(0 < string_view("hello" ).compare(2, 2, "hello" , 2, 1), "" ); |
472 | static_assert(0 > string_view("hello" ).compare(2, 2, "hello" , 2, 3), "" ); |
473 | static_assert(0 < string_view("hello" ).compare(2, 2, "hellola" , 5, 2), "" ); |
474 | static_assert(0 > string_view("hello" ).compare(2, 2, "hellolz" , 5, 2), "" ); |
475 | } // namespace test_compare_overload6 |
476 | |
477 | namespace test_equality_comparison { |
478 | static_assert(string_view("hi" ) == string_view("hi" ), "" ); |
479 | static_assert(!(string_view("hi" ) != string_view("hi" )), "" ); |
480 | |
481 | static_assert(string_view("" ) == string_view("" ), "" ); |
482 | static_assert(!(string_view("" ) != string_view("" )), "" ); |
483 | |
484 | static_assert(string_view("hi" ) != string_view("hi2" ), "" ); |
485 | static_assert(!(string_view("hi" ) == string_view("hi2" )), "" ); |
486 | |
487 | static_assert(string_view("hi2" ) != string_view("hi" ), "" ); |
488 | static_assert(!(string_view("hi2" ) == string_view("hi" )), "" ); |
489 | |
490 | static_assert(string_view("hi" ) != string_view("ha" ), "" ); |
491 | static_assert(!(string_view("hi" ) == string_view("ha" )), "" ); |
492 | |
493 | static_assert(string_view("ha" ) != string_view("hi" ), "" ); |
494 | static_assert(!(string_view("ha" ) == string_view("hi" )), "" ); |
495 | } // namespace test_equality_comparison |
496 | |
497 | namespace test_less_than { |
498 | static_assert(!(string_view("" ) < string_view("" )), "" ); |
499 | static_assert(!(string_view("a" ) < string_view("a" )), "" ); |
500 | static_assert(!(string_view("hello" ) < string_view("hello" )), "" ); |
501 | static_assert(!(string_view("hello" ) < string_view("" )), "" ); |
502 | static_assert(!(string_view("hello" ) < string_view("aello" )), "" ); |
503 | static_assert(!(string_view("hello" ) < string_view("a" )), "" ); |
504 | static_assert(!(string_view("hello" ) < string_view("abcdefghijklmno" )), "" ); |
505 | static_assert(!(string_view("hello" ) < string_view("hela" )), "" ); |
506 | static_assert(!(string_view("hello" ) < string_view("helao" )), "" ); |
507 | static_assert(!(string_view("hello" ) < string_view("helaobcdefgh" )), "" ); |
508 | static_assert(!(string_view("hello" ) < string_view("hell" )), "" ); |
509 | static_assert(string_view("" ) < string_view("hello" ), "" ); |
510 | static_assert(string_view("hello" ) < string_view("zello" ), "" ); |
511 | static_assert(string_view("hello" ) < string_view("z" ), "" ); |
512 | static_assert(string_view("hello" ) < string_view("zabcdefghijklmno" ), "" ); |
513 | static_assert(string_view("hello" ) < string_view("helz" ), "" ); |
514 | static_assert(string_view("hello" ) < string_view("helzo" ), "" ); |
515 | static_assert(string_view("hello" ) < string_view("helzobcdefgh" ), "" ); |
516 | static_assert(string_view("hello" ) < string_view("helloa" ), "" ); |
517 | } // namespace test_less_than |
518 | |
519 | namespace test_less_or_equal_than { |
520 | static_assert(string_view("" ) <= string_view("" ), "" ); |
521 | static_assert(string_view("a" ) <= string_view("a" ), "" ); |
522 | static_assert(string_view("hello" ) <= string_view("hello" ), "" ); |
523 | static_assert(!(string_view("hello" ) <= string_view("" )), "" ); |
524 | static_assert(!(string_view("hello" ) <= string_view("aello" )), "" ); |
525 | static_assert(!(string_view("hello" ) <= string_view("a" )), "" ); |
526 | static_assert(!(string_view("hello" ) <= string_view("abcdefghijklmno" )), "" ); |
527 | static_assert(!(string_view("hello" ) <= string_view("hela" )), "" ); |
528 | static_assert(!(string_view("hello" ) <= string_view("helao" )), "" ); |
529 | static_assert(!(string_view("hello" ) <= string_view("helaobcdefgh" )), "" ); |
530 | static_assert(!(string_view("hello" ) <= string_view("hell" )), "" ); |
531 | static_assert(string_view("" ) <= string_view("hello" ), "" ); |
532 | static_assert(string_view("hello" ) <= string_view("zello" ), "" ); |
533 | static_assert(string_view("hello" ) <= string_view("z" ), "" ); |
534 | static_assert(string_view("hello" ) <= string_view("zabcdefghijklmno" ), "" ); |
535 | static_assert(string_view("hello" ) <= string_view("helz" ), "" ); |
536 | static_assert(string_view("hello" ) <= string_view("helzo" ), "" ); |
537 | static_assert(string_view("hello" ) <= string_view("helzobcdefgh" ), "" ); |
538 | static_assert(string_view("hello" ) <= string_view("helloa" ), "" ); |
539 | } // namespace test_less_or_equal_than |
540 | |
541 | namespace test_greater_than { |
542 | static_assert(!(string_view("" ) > string_view("" )), "" ); |
543 | static_assert(!(string_view("a" ) > string_view("a" )), "" ); |
544 | static_assert(!(string_view("hello" ) > string_view("hello" )), "" ); |
545 | static_assert(string_view("hello" ) > string_view("" ), "" ); |
546 | static_assert(string_view("hello" ) > string_view("aello" ), "" ); |
547 | static_assert(string_view("hello" ) > string_view("a" ), "" ); |
548 | static_assert(string_view("hello" ) > string_view("abcdefghijklmno" ), "" ); |
549 | static_assert(string_view("hello" ) > string_view("hela" ), "" ); |
550 | static_assert(string_view("hello" ) > string_view("helao" ), "" ); |
551 | static_assert(string_view("hello" ) > string_view("helaobcdefgh" ), "" ); |
552 | static_assert(string_view("hello" ) > string_view("hell" ), "" ); |
553 | static_assert(!(string_view("" ) > string_view("hello" )), "" ); |
554 | static_assert(!(string_view("hello" ) > string_view("zello" )), "" ); |
555 | static_assert(!(string_view("hello" ) > string_view("z" )), "" ); |
556 | static_assert(!(string_view("hello" ) > string_view("zabcdefghijklmno" )), "" ); |
557 | static_assert(!(string_view("hello" ) > string_view("helz" )), "" ); |
558 | static_assert(!(string_view("hello" ) > string_view("helzo" )), "" ); |
559 | static_assert(!(string_view("hello" ) > string_view("helzobcdefgh" )), "" ); |
560 | static_assert(!(string_view("hello" ) > string_view("helloa" )), "" ); |
561 | } // namespace test_greater_than |
562 | |
563 | namespace test_greater_or_equals_than { |
564 | static_assert(string_view("" ) >= string_view("" ), "" ); |
565 | static_assert(string_view("a" ) >= string_view("a" ), "" ); |
566 | static_assert(string_view("hello" ) >= string_view("hello" ), "" ); |
567 | static_assert(string_view("hello" ) >= string_view("" ), "" ); |
568 | static_assert(string_view("hello" ) >= string_view("aello" ), "" ); |
569 | static_assert(string_view("hello" ) >= string_view("a" ), "" ); |
570 | static_assert(string_view("hello" ) >= string_view("abcdefghijklmno" ), "" ); |
571 | static_assert(string_view("hello" ) >= string_view("hela" ), "" ); |
572 | static_assert(string_view("hello" ) >= string_view("helao" ), "" ); |
573 | static_assert(string_view("hello" ) >= string_view("helaobcdefgh" ), "" ); |
574 | static_assert(string_view("hello" ) >= string_view("hell" ), "" ); |
575 | static_assert(!(string_view("" ) >= string_view("hello" )), "" ); |
576 | static_assert(!(string_view("hello" ) >= string_view("zello" )), "" ); |
577 | static_assert(!(string_view("hello" ) >= string_view("z" )), "" ); |
578 | static_assert(!(string_view("hello" ) >= string_view("zabcdefghijklmno" )), "" ); |
579 | static_assert(!(string_view("hello" ) >= string_view("helz" )), "" ); |
580 | static_assert(!(string_view("hello" ) >= string_view("helzo" )), "" ); |
581 | static_assert(!(string_view("hello" ) >= string_view("helzobcdefgh" )), "" ); |
582 | static_assert(!(string_view("hello" ) >= string_view("helloa" )), "" ); |
583 | } // namespace test_greater_or_equals_than |
584 | |
585 | namespace test_starts_with { |
586 | static_assert(string_view("hi" ).starts_with(string_view("hi" )), "" ); |
587 | static_assert(string_view("" ).starts_with(string_view("" )), "" ); |
588 | static_assert(string_view("hi2" ).starts_with(string_view("" )), "" ); |
589 | static_assert(!string_view("" ).starts_with(string_view("hi" )), "" ); |
590 | static_assert(string_view("hi2" ).starts_with(string_view("hi" )), "" ); |
591 | static_assert(!string_view("hi" ).starts_with(string_view("hi2" )), "" ); |
592 | static_assert(!string_view("hi" ).starts_with(string_view("ha" )), "" ); |
593 | |
594 | static_assert(string_view("hi" ).starts_with("hi" ), "" ); |
595 | static_assert(string_view("" ).starts_with("" ), "" ); |
596 | static_assert(string_view("hi2" ).starts_with("" ), "" ); |
597 | static_assert(!string_view("" ).starts_with("hi" ), "" ); |
598 | static_assert(string_view("hi2" ).starts_with("hi" ), "" ); |
599 | static_assert(!string_view("hi" ).starts_with("hi2" ), "" ); |
600 | static_assert(!string_view("hi" ).starts_with("ha" ), "" ); |
601 | |
602 | static_assert(!string_view("" ).starts_with('a'), "" ); |
603 | static_assert(!string_view("" ).starts_with('\0'), "" ); |
604 | static_assert(!string_view("hello" ).starts_with('a'), "" ); |
605 | static_assert(string_view("hello" ).starts_with('h'), "" ); |
606 | } // namespace test_starts_with |
607 | |
608 | namespace test_ends_with { |
609 | static_assert(string_view("hi" ).ends_with(string_view("hi" )), "" ); |
610 | static_assert(string_view("" ).ends_with(string_view("" )), "" ); |
611 | static_assert(string_view("hi2" ).ends_with(string_view("" )), "" ); |
612 | static_assert(!string_view("" ).ends_with(string_view("hi" )), "" ); |
613 | static_assert(string_view("hi2" ).ends_with(string_view("i2" )), "" ); |
614 | static_assert(!string_view("i2" ).ends_with(string_view("hi2" )), "" ); |
615 | static_assert(!string_view("hi" ).ends_with(string_view("ha" )), "" ); |
616 | |
617 | static_assert(string_view("hi" ).ends_with("hi" ), "" ); |
618 | static_assert(string_view("" ).ends_with("" ), "" ); |
619 | static_assert(string_view("hi2" ).ends_with("" ), "" ); |
620 | static_assert(!string_view("" ).ends_with("hi" ), "" ); |
621 | static_assert(string_view("hi2" ).ends_with("i2" ), "" ); |
622 | static_assert(!string_view("i2" ).ends_with("hi2" ), "" ); |
623 | static_assert(!string_view("hi" ).ends_with("ha" ), "" ); |
624 | |
625 | static_assert(!string_view("" ).ends_with('a'), "" ); |
626 | static_assert(!string_view("" ).ends_with('\0'), "" ); |
627 | static_assert(!string_view("hello" ).ends_with('a'), "" ); |
628 | static_assert(string_view("hello" ).ends_with('o'), "" ); |
629 | } // namespace test_ends_with |
630 | |
631 | namespace test_find_overload1 { |
632 | static_assert(0 == string_view("" ).find(string_view("" )), "" ); |
633 | static_assert(string_view::npos == string_view("" ).find(string_view("a" )), "" ); |
634 | static_assert( |
635 | string_view::npos == string_view("" ).find(string_view("" ), 1), |
636 | "" ); |
637 | static_assert(0 == string_view("abc" ).find(string_view("" )), "" ); |
638 | static_assert(2 == string_view("abc" ).find(string_view("" ), 2), "" ); |
639 | static_assert(0 == string_view("abc" ).find(string_view("a" )), "" ); |
640 | static_assert(0 == string_view("abc" ).find(string_view("ab" )), "" ); |
641 | static_assert(0 == string_view("abc" ).find(string_view("abc" )), "" ); |
642 | static_assert(1 == string_view("abc" ).find(string_view("bc" )), "" ); |
643 | static_assert(1 == string_view("abc" ).find(string_view("b" )), "" ); |
644 | static_assert(2 == string_view("abc" ).find(string_view("c" )), "" ); |
645 | static_assert(0 == string_view("abc" ).find(string_view("a" )), "" ); |
646 | static_assert(0 == string_view("abc" ).find(string_view("ab" )), "" ); |
647 | static_assert(0 == string_view("abc" ).find(string_view("abc" )), "" ); |
648 | static_assert(1 == string_view("ababa" ).find(string_view("ba" )), "" ); |
649 | static_assert(3 == string_view("ababa" ).find(string_view("ba" ), 2), "" ); |
650 | static_assert(3 == string_view("ababa" ).find(string_view("ba" ), 3), "" ); |
651 | static_assert( |
652 | string_view::npos == string_view("ababa" ).find(string_view("ba" ), 4), |
653 | "" ); |
654 | static_assert( |
655 | string_view::npos == string_view("abc" ).find(string_view("abcd" )), |
656 | "" ); |
657 | } // namespace test_find_overload1 |
658 | |
659 | namespace test_find_overload2 { |
660 | static_assert(string_view::npos == string_view("" ).find('a'), "" ); |
661 | static_assert(0 == string_view("a" ).find('a'), "" ); |
662 | static_assert(0 == string_view("abc" ).find('a'), "" ); |
663 | static_assert(string_view::npos == string_view("a" ).find('a', 1), "" ); |
664 | static_assert(1 == string_view("abc" ).find('b'), "" ); |
665 | static_assert(1 == string_view("abc" ).find('b', 1), "" ); |
666 | static_assert(string_view::npos == string_view("abc" ).find('b', 2), "" ); |
667 | static_assert(2 == string_view("abc" ).find('c'), "" ); |
668 | static_assert(2 == string_view("abc" ).find('c', 1), "" ); |
669 | static_assert(2 == string_view("abc" ).find('c', 2), "" ); |
670 | static_assert(string_view::npos == string_view("abc" ).find('c', 3), "" ); |
671 | static_assert(string_view::npos == string_view("abc" ).find('a', 100), "" ); |
672 | static_assert(string_view::npos == string_view("abc" ).find('z'), "" ); |
673 | static_assert(0 == string_view("ababa" ).find('a'), "" ); |
674 | static_assert(0 == string_view("ababa" ).find('a', 0), "" ); |
675 | static_assert(2 == string_view("ababa" ).find('a', 1), "" ); |
676 | static_assert(2 == string_view("ababa" ).find('a', 2), "" ); |
677 | static_assert(4 == string_view("ababa" ).find('a', 3), "" ); |
678 | static_assert(4 == string_view("ababa" ).find('a', 4), "" ); |
679 | static_assert(string_view::npos == string_view("ababa" ).find('a', 5), "" ); |
680 | } // namespace test_find_overload2 |
681 | |
682 | namespace test_find_overload3 { |
683 | static_assert(0 == string_view("" ).find("" , 0, 0), "" ); |
684 | static_assert(string_view::npos == string_view("" ).find("a" , 0, 1), "" ); |
685 | static_assert(string_view::npos == string_view("" ).find("" , 1, 0), "" ); |
686 | static_assert(0 == string_view("abc" ).find("" , 0, 0), "" ); |
687 | static_assert(2 == string_view("abc" ).find("" , 2, 0), "" ); |
688 | static_assert(0 == string_view("abc" ).find("a" , 0, 1), "" ); |
689 | static_assert(0 == string_view("abc" ).find("ab" , 0, 2), "" ); |
690 | static_assert(0 == string_view("abc" ).find("abc" , 0, 3), "" ); |
691 | static_assert(1 == string_view("abc" ).find("bc" , 0, 2), "" ); |
692 | static_assert(1 == string_view("abc" ).find("b" , 0, 1), "" ); |
693 | static_assert(2 == string_view("abc" ).find("c" , 0, 1), "" ); |
694 | static_assert(0 == string_view("abc" ).find("a" , 0, 1), "" ); |
695 | static_assert(0 == string_view("abc" ).find("ab" , 0, 2), "" ); |
696 | static_assert(0 == string_view("abc" ).find("abc" , 0, 3), "" ); |
697 | static_assert(1 == string_view("ababa" ).find("ba" , 0, 2), "" ); |
698 | static_assert(3 == string_view("ababa" ).find("ba" , 2, 2), "" ); |
699 | static_assert(3 == string_view("ababa" ).find("ba" , 3, 2), "" ); |
700 | static_assert(string_view::npos == string_view("ababa" ).find("ba" , 4, 2), "" ); |
701 | static_assert(string_view::npos == string_view("abc" ).find("abcd" , 0, 4), "" ); |
702 | } // namespace test_find_overload3 |
703 | |
704 | namespace test_find_overload4 { |
705 | static_assert(0 == string_view("" ).find("" ), "" ); |
706 | static_assert(string_view::npos == string_view("" ).find("a" ), "" ); |
707 | static_assert(string_view::npos == string_view("" ).find("" , 1), "" ); |
708 | static_assert(0 == string_view("abc" ).find("" ), "" ); |
709 | static_assert(2 == string_view("abc" ).find("" , 2), "" ); |
710 | static_assert(0 == string_view("abc" ).find("a" ), "" ); |
711 | static_assert(0 == string_view("abc" ).find("ab" ), "" ); |
712 | static_assert(0 == string_view("abc" ).find("abc" ), "" ); |
713 | static_assert(1 == string_view("abc" ).find("bc" ), "" ); |
714 | static_assert(1 == string_view("abc" ).find("b" ), "" ); |
715 | static_assert(2 == string_view("abc" ).find("c" ), "" ); |
716 | static_assert(0 == string_view("abc" ).find("a" ), "" ); |
717 | static_assert(0 == string_view("abc" ).find("ab" ), "" ); |
718 | static_assert(0 == string_view("abc" ).find("abc" ), "" ); |
719 | static_assert(1 == string_view("ababa" ).find("ba" ), "" ); |
720 | static_assert(3 == string_view("ababa" ).find("ba" , 2), "" ); |
721 | static_assert(3 == string_view("ababa" ).find("ba" , 3), "" ); |
722 | static_assert(string_view::npos == string_view("ababa" ).find("ba" , 4), "" ); |
723 | static_assert(string_view::npos == string_view("abc" ).find("abcd" ), "" ); |
724 | } // namespace test_find_overload4 |
725 | |
726 | namespace test_rfind_overload1 { |
727 | static_assert(0 == string_view("" ).rfind(string_view("" )), "" ); |
728 | static_assert(string_view::npos == string_view("" ).rfind(string_view("a" )), "" ); |
729 | static_assert(0 == string_view("" ).rfind(string_view("" ), 1), "" ); |
730 | static_assert(3 == string_view("abc" ).rfind(string_view("" )), "" ); |
731 | static_assert(0 == string_view("abc" ).rfind(string_view("" ), 0), "" ); |
732 | static_assert(0 == string_view("abc" ).rfind(string_view("a" )), "" ); |
733 | static_assert(0 == string_view("abc" ).rfind(string_view("ab" )), "" ); |
734 | static_assert(0 == string_view("abc" ).rfind(string_view("abc" )), "" ); |
735 | static_assert(1 == string_view("abc" ).rfind(string_view("bc" )), "" ); |
736 | static_assert(1 == string_view("abc" ).rfind(string_view("b" )), "" ); |
737 | static_assert(2 == string_view("abc" ).rfind(string_view("c" )), "" ); |
738 | static_assert(0 == string_view("abc" ).rfind(string_view("a" )), "" ); |
739 | static_assert(0 == string_view("abc" ).rfind(string_view("ab" )), "" ); |
740 | static_assert(0 == string_view("abc" ).rfind(string_view("abc" )), "" ); |
741 | static_assert(3 == string_view("ababa" ).rfind(string_view("ba" )), "" ); |
742 | static_assert(1 == string_view("ababa" ).rfind(string_view("ba" ), 2), "" ); |
743 | static_assert(1 == string_view("ababa" ).rfind(string_view("ba" ), 1), "" ); |
744 | static_assert( |
745 | string_view::npos == string_view("ababa" ).rfind(string_view("ba" ), 0), |
746 | "" ); |
747 | static_assert( |
748 | string_view::npos == string_view("abc" ).rfind(string_view("abcd" )), |
749 | "" ); |
750 | } // namespace test_rfind_overload1 |
751 | |
752 | namespace test_rfind_overload2 { |
753 | static_assert(string_view::npos == string_view("" ).rfind('a'), "" ); |
754 | static_assert(0 == string_view("a" ).rfind('a'), "" ); |
755 | static_assert(0 == string_view("abc" ).rfind('a'), "" ); |
756 | static_assert(0 == string_view("a" ).rfind('a', 0), "" ); |
757 | static_assert(1 == string_view("abc" ).rfind('b'), "" ); |
758 | static_assert(string_view::npos == string_view("abc" ).rfind('b', 0), "" ); |
759 | static_assert(1 == string_view("abc" ).rfind('b', 1), "" ); |
760 | static_assert(2 == string_view("abc" ).rfind('c'), "" ); |
761 | static_assert(string_view::npos == string_view("abc" ).rfind('c', 0), "" ); |
762 | static_assert(string_view::npos == string_view("abc" ).rfind('c', 1), "" ); |
763 | static_assert(2 == string_view("abc" ).rfind('c', 2), "" ); |
764 | static_assert(2 == string_view("abc" ).rfind('c', 3), "" ); |
765 | static_assert(0 == string_view("abc" ).rfind('a', 100), "" ); |
766 | static_assert(string_view::npos == string_view("abc" ).rfind('z'), "" ); |
767 | static_assert(4 == string_view("ababa" ).rfind('a'), "" ); |
768 | static_assert(0 == string_view("ababa" ).rfind('a', 0), "" ); |
769 | static_assert(0 == string_view("ababa" ).rfind('a', 1), "" ); |
770 | static_assert(2 == string_view("ababa" ).rfind('a', 2), "" ); |
771 | static_assert(2 == string_view("ababa" ).rfind('a', 3), "" ); |
772 | static_assert(4 == string_view("ababa" ).rfind('a', 4), "" ); |
773 | static_assert(4 == string_view("ababa" ).rfind('a', 5), "" ); |
774 | } // namespace test_rfind_overload2 |
775 | |
776 | namespace test_rfind_overload3 { |
777 | static_assert(0 == string_view("" ).rfind("" , string_view::npos, 0), "" ); |
778 | static_assert( |
779 | string_view::npos == string_view("" ).rfind("a" , string_view::npos, 1), |
780 | "" ); |
781 | static_assert(0 == string_view("" ).rfind("" , 1, 0), "" ); |
782 | static_assert(3 == string_view("abc" ).rfind("" , string_view::npos, 0), "" ); |
783 | static_assert(0 == string_view("abc" ).rfind("" , 0, 0), "" ); |
784 | static_assert(0 == string_view("abc" ).rfind("a" , string_view::npos, 1), "" ); |
785 | static_assert(0 == string_view("abc" ).rfind("ab" , string_view::npos, 2), "" ); |
786 | static_assert(0 == string_view("abc" ).rfind("abc" , string_view::npos, 3), "" ); |
787 | static_assert(1 == string_view("abc" ).rfind("bc" , string_view::npos, 2), "" ); |
788 | static_assert(1 == string_view("abc" ).rfind("b" , string_view::npos, 1), "" ); |
789 | static_assert(2 == string_view("abc" ).rfind("c" , string_view::npos, 1), "" ); |
790 | static_assert(0 == string_view("abc" ).rfind("a" , string_view::npos, 1), "" ); |
791 | static_assert(0 == string_view("abc" ).rfind("ab" , string_view::npos, 2), "" ); |
792 | static_assert(0 == string_view("abc" ).rfind("abc" , string_view::npos, 3), "" ); |
793 | static_assert(3 == string_view("ababa" ).rfind("ba" , string_view::npos, 2), "" ); |
794 | static_assert(1 == string_view("ababa" ).rfind("ba" , 2, 2), "" ); |
795 | static_assert(1 == string_view("ababa" ).rfind("ba" , 1, 2), "" ); |
796 | static_assert(string_view::npos == string_view("ababa" ).rfind("ba" , 0, 2), "" ); |
797 | static_assert( |
798 | string_view::npos == string_view("abc" ).rfind("abcd" , string_view::npos, 4), |
799 | "" ); |
800 | } // namespace test_rfind_overload3 |
801 | |
802 | namespace test_rfind_overload4 { |
803 | static_assert(0 == string_view("" ).rfind("" ), "" ); |
804 | static_assert(string_view::npos == string_view("" ).rfind("a" ), "" ); |
805 | static_assert(0 == string_view("" ).rfind("" , 1), "" ); |
806 | static_assert(3 == string_view("abc" ).rfind("" ), "" ); |
807 | static_assert(0 == string_view("abc" ).rfind("" , 0), "" ); |
808 | static_assert(0 == string_view("abc" ).rfind("a" ), "" ); |
809 | static_assert(0 == string_view("abc" ).rfind("ab" ), "" ); |
810 | static_assert(0 == string_view("abc" ).rfind("abc" ), "" ); |
811 | static_assert(1 == string_view("abc" ).rfind("bc" ), "" ); |
812 | static_assert(1 == string_view("abc" ).rfind("b" ), "" ); |
813 | static_assert(2 == string_view("abc" ).rfind("c" ), "" ); |
814 | static_assert(0 == string_view("abc" ).rfind("a" ), "" ); |
815 | static_assert(0 == string_view("abc" ).rfind("ab" ), "" ); |
816 | static_assert(0 == string_view("abc" ).rfind("abc" ), "" ); |
817 | static_assert(3 == string_view("ababa" ).rfind("ba" ), "" ); |
818 | static_assert(1 == string_view("ababa" ).rfind("ba" , 2), "" ); |
819 | static_assert(1 == string_view("ababa" ).rfind("ba" , 1), "" ); |
820 | static_assert(string_view::npos == string_view("ababa" ).rfind("ba" , 0), "" ); |
821 | static_assert(string_view::npos == string_view("abc" ).rfind("abcd" ), "" ); |
822 | } // namespace test_rfind_overload4 |
823 | |
824 | namespace test_find_first_of_overload1 { |
825 | static_assert( |
826 | string_view::npos == string_view("" ).find_first_of(string_view("" )), |
827 | "" ); |
828 | static_assert( |
829 | string_view::npos == string_view("" ).find_first_of(string_view("a" )), |
830 | "" ); |
831 | static_assert( |
832 | string_view::npos == string_view("" ).find_first_of(string_view("abc" )), |
833 | "" ); |
834 | static_assert( |
835 | string_view::npos == string_view("abc" ).find_first_of(string_view("" )), |
836 | "" ); |
837 | static_assert( |
838 | string_view::npos == string_view("abc" ).find_first_of(string_view("d" )), |
839 | "" ); |
840 | static_assert( |
841 | string_view::npos == string_view("abc" ).find_first_of(string_view("def" )), |
842 | "" ); |
843 | |
844 | static_assert(0 == string_view("abcabc" ).find_first_of(string_view("a" )), "" ); |
845 | static_assert(1 == string_view("abcabc" ).find_first_of(string_view("b" )), "" ); |
846 | static_assert(2 == string_view("abcabc" ).find_first_of(string_view("c" )), "" ); |
847 | static_assert(1 == string_view("abcabc" ).find_first_of(string_view("bc" )), "" ); |
848 | static_assert(1 == string_view("abcabc" ).find_first_of(string_view("cbd" )), "" ); |
849 | |
850 | static_assert( |
851 | string_view::npos == string_view("" ).find_first_of(string_view("" ), 1), |
852 | "" ); |
853 | static_assert( |
854 | string_view::npos == string_view("" ).find_first_of(string_view("a" ), 1), |
855 | "" ); |
856 | static_assert( |
857 | string_view::npos == string_view("" ).find_first_of(string_view("abc" ), 100), |
858 | "" ); |
859 | static_assert( |
860 | string_view::npos == string_view("abc" ).find_first_of(string_view("" ), 1), |
861 | "" ); |
862 | static_assert( |
863 | string_view::npos == string_view("abc" ).find_first_of(string_view("d" ), 3), |
864 | "" ); |
865 | static_assert( |
866 | string_view::npos == |
867 | string_view("abc" ).find_first_of(string_view("def" ), 2), |
868 | "" ); |
869 | |
870 | static_assert( |
871 | 3 == string_view("abcabc" ).find_first_of(string_view("a" ), 1), |
872 | "" ); |
873 | static_assert( |
874 | 4 == string_view("abcabc" ).find_first_of(string_view("b" ), 3), |
875 | "" ); |
876 | static_assert( |
877 | 5 == string_view("abcabc" ).find_first_of(string_view("c" ), 5), |
878 | "" ); |
879 | static_assert( |
880 | 4 == string_view("abcabc" ).find_first_of(string_view("bc" ), 3), |
881 | "" ); |
882 | static_assert( |
883 | 4 == string_view("abcabc" ).find_first_of(string_view("cbd" ), 4), |
884 | "" ); |
885 | } // namespace test_find_first_of_overload1 |
886 | |
887 | namespace test_find_first_of_overload2 { |
888 | static_assert(string_view::npos == string_view("" ).find_first_of('a'), "" ); |
889 | static_assert(0 == string_view("a" ).find_first_of('a'), "" ); |
890 | static_assert(0 == string_view("abc" ).find_first_of('a'), "" ); |
891 | static_assert(string_view::npos == string_view("a" ).find_first_of('a', 1), "" ); |
892 | static_assert(1 == string_view("abc" ).find_first_of('b'), "" ); |
893 | static_assert(1 == string_view("abc" ).find_first_of('b', 1), "" ); |
894 | static_assert( |
895 | string_view::npos == string_view("abc" ).find_first_of('b', 2), |
896 | "" ); |
897 | static_assert(2 == string_view("abc" ).find_first_of('c'), "" ); |
898 | static_assert(2 == string_view("abc" ).find_first_of('c', 1), "" ); |
899 | static_assert(2 == string_view("abc" ).find_first_of('c', 2), "" ); |
900 | static_assert( |
901 | string_view::npos == string_view("abc" ).find_first_of('c', 3), |
902 | "" ); |
903 | static_assert( |
904 | string_view::npos == string_view("abc" ).find_first_of('a', 100), |
905 | "" ); |
906 | static_assert(string_view::npos == string_view("abc" ).find_first_of('z'), "" ); |
907 | static_assert(0 == string_view("ababa" ).find_first_of('a'), "" ); |
908 | static_assert(0 == string_view("ababa" ).find_first_of('a', 0), "" ); |
909 | static_assert(2 == string_view("ababa" ).find_first_of('a', 1), "" ); |
910 | static_assert(2 == string_view("ababa" ).find_first_of('a', 2), "" ); |
911 | static_assert(4 == string_view("ababa" ).find_first_of('a', 3), "" ); |
912 | static_assert(4 == string_view("ababa" ).find_first_of('a', 4), "" ); |
913 | static_assert( |
914 | string_view::npos == string_view("ababa" ).find_first_of('a', 5), |
915 | "" ); |
916 | } // namespace test_find_first_of_overload2 |
917 | |
918 | namespace test_find_first_of_overload3 { |
919 | static_assert( |
920 | string_view::npos == string_view("" ).find_first_of("ab" , 0, 0), |
921 | "" ); |
922 | static_assert( |
923 | string_view::npos == string_view("" ).find_first_of("abc" , 0, 1), |
924 | "" ); |
925 | static_assert( |
926 | string_view::npos == string_view("" ).find_first_of("abcdef" , 0, 3), |
927 | "" ); |
928 | static_assert( |
929 | string_view::npos == string_view("abc" ).find_first_of("abcdef" , 0, 0), |
930 | "" ); |
931 | static_assert( |
932 | string_view::npos == string_view("abc" ).find_first_of("defa" , 0, 1), |
933 | "" ); |
934 | static_assert( |
935 | string_view::npos == string_view("abc" ).find_first_of("defabc" , 0, 3), |
936 | "" ); |
937 | |
938 | static_assert(0 == string_view("abcabc" ).find_first_of("abc" , 0, 1), "" ); |
939 | static_assert(1 == string_view("abcabc" ).find_first_of("bac" , 0, 1), "" ); |
940 | static_assert(2 == string_view("abcabc" ).find_first_of("cab" , 0, 1), "" ); |
941 | static_assert(1 == string_view("abcabc" ).find_first_of("bccda" , 0, 2), "" ); |
942 | static_assert(1 == string_view("abcabc" ).find_first_of("cbdab" , 0, 3), "" ); |
943 | |
944 | static_assert( |
945 | string_view::npos == string_view("" ).find_first_of("ab" , 1, 0), |
946 | "" ); |
947 | static_assert( |
948 | string_view::npos == string_view("" ).find_first_of("abc" , 1, 1), |
949 | "" ); |
950 | static_assert( |
951 | string_view::npos == string_view("" ).find_first_of("abcdef" , 100, 3), |
952 | "" ); |
953 | static_assert( |
954 | string_view::npos == string_view("abc" ).find_first_of("abcdef" , 1, 0), |
955 | "" ); |
956 | static_assert( |
957 | string_view::npos == string_view("abc" ).find_first_of("defa" , 3, 1), |
958 | "" ); |
959 | static_assert( |
960 | string_view::npos == string_view("abc" ).find_first_of("defabc" , 2, 3), |
961 | "" ); |
962 | |
963 | static_assert(3 == string_view("abcabc" ).find_first_of("abc" , 1, 1), "" ); |
964 | static_assert(4 == string_view("abcabc" ).find_first_of("bac" , 3, 1), "" ); |
965 | static_assert(5 == string_view("abcabc" ).find_first_of("cab" , 5, 1), "" ); |
966 | static_assert(4 == string_view("abcabc" ).find_first_of("bccda" , 3, 2), "" ); |
967 | static_assert(4 == string_view("abcabc" ).find_first_of("cbdab" , 4, 3), "" ); |
968 | } // namespace test_find_first_of_overload3 |
969 | |
970 | namespace test_find_first_of_overload4 { |
971 | static_assert(string_view::npos == string_view("" ).find_first_of("" ), "" ); |
972 | static_assert(string_view::npos == string_view("" ).find_first_of("a" ), "" ); |
973 | static_assert(string_view::npos == string_view("" ).find_first_of("abc" ), "" ); |
974 | static_assert(string_view::npos == string_view("abc" ).find_first_of("" ), "" ); |
975 | static_assert(string_view::npos == string_view("abc" ).find_first_of("d" ), "" ); |
976 | static_assert(string_view::npos == string_view("abc" ).find_first_of("def" ), "" ); |
977 | |
978 | static_assert(0 == string_view("abcabc" ).find_first_of("a" ), "" ); |
979 | static_assert(1 == string_view("abcabc" ).find_first_of("b" ), "" ); |
980 | static_assert(2 == string_view("abcabc" ).find_first_of("c" ), "" ); |
981 | static_assert(1 == string_view("abcabc" ).find_first_of("bc" ), "" ); |
982 | static_assert(1 == string_view("abcabc" ).find_first_of("cbd" ), "" ); |
983 | |
984 | static_assert(string_view::npos == string_view("" ).find_first_of("" , 1), "" ); |
985 | static_assert(string_view::npos == string_view("" ).find_first_of("a" , 1), "" ); |
986 | static_assert( |
987 | string_view::npos == string_view("" ).find_first_of("abc" , 100), |
988 | "" ); |
989 | static_assert(string_view::npos == string_view("abc" ).find_first_of("" , 1), "" ); |
990 | static_assert( |
991 | string_view::npos == string_view("abc" ).find_first_of("d" , 3), |
992 | "" ); |
993 | static_assert( |
994 | string_view::npos == string_view("abc" ).find_first_of("def" , 2), |
995 | "" ); |
996 | |
997 | static_assert(3 == string_view("abcabc" ).find_first_of("a" , 1), "" ); |
998 | static_assert(4 == string_view("abcabc" ).find_first_of("b" , 3), "" ); |
999 | static_assert(5 == string_view("abcabc" ).find_first_of("c" , 5), "" ); |
1000 | static_assert(4 == string_view("abcabc" ).find_first_of("bc" , 3), "" ); |
1001 | static_assert(4 == string_view("abcabc" ).find_first_of("cbd" , 4), "" ); |
1002 | } // namespace test_find_first_of_overload4 |
1003 | |
1004 | namespace test_find_last_of_overload1 { |
1005 | static_assert( |
1006 | string_view::npos == string_view("" ).find_last_of(string_view("" )), |
1007 | "" ); |
1008 | static_assert( |
1009 | string_view::npos == string_view("" ).find_last_of(string_view("a" )), |
1010 | "" ); |
1011 | static_assert( |
1012 | string_view::npos == string_view("" ).find_last_of(string_view("abc" )), |
1013 | "" ); |
1014 | static_assert( |
1015 | string_view::npos == string_view("abc" ).find_last_of(string_view("" )), |
1016 | "" ); |
1017 | static_assert( |
1018 | string_view::npos == string_view("abc" ).find_last_of(string_view("d" )), |
1019 | "" ); |
1020 | static_assert( |
1021 | string_view::npos == string_view("abc" ).find_last_of(string_view("def" )), |
1022 | "" ); |
1023 | |
1024 | static_assert(3 == string_view("abcabc" ).find_last_of(string_view("a" )), "" ); |
1025 | static_assert(4 == string_view("abcabc" ).find_last_of(string_view("b" )), "" ); |
1026 | static_assert(5 == string_view("abcabc" ).find_last_of(string_view("c" )), "" ); |
1027 | static_assert(5 == string_view("abcabc" ).find_last_of(string_view("bc" )), "" ); |
1028 | static_assert(5 == string_view("abcabc" ).find_last_of(string_view("cbd" )), "" ); |
1029 | |
1030 | static_assert( |
1031 | string_view::npos == string_view("" ).find_last_of(string_view("" ), 1), |
1032 | "" ); |
1033 | static_assert( |
1034 | string_view::npos == string_view("" ).find_last_of(string_view("a" ), 0), |
1035 | "" ); |
1036 | static_assert( |
1037 | string_view::npos == string_view("" ).find_last_of(string_view("abc" ), 100), |
1038 | "" ); |
1039 | static_assert( |
1040 | string_view::npos == string_view("abc" ).find_last_of(string_view("" ), 1), |
1041 | "" ); |
1042 | static_assert( |
1043 | string_view::npos == string_view("abc" ).find_last_of(string_view("d" ), 3), |
1044 | "" ); |
1045 | static_assert( |
1046 | string_view::npos == string_view("abc" ).find_last_of(string_view("def" ), 2), |
1047 | "" ); |
1048 | |
1049 | static_assert(0 == string_view("abcabc" ).find_last_of(string_view("a" ), 2), "" ); |
1050 | static_assert(1 == string_view("abcabc" ).find_last_of(string_view("b" ), 3), "" ); |
1051 | static_assert(2 == string_view("abcabc" ).find_last_of(string_view("c" ), 2), "" ); |
1052 | static_assert( |
1053 | 2 == string_view("abcabc" ).find_last_of(string_view("bc" ), 3), |
1054 | "" ); |
1055 | static_assert( |
1056 | 2 == string_view("abcabc" ).find_last_of(string_view("cbd" ), 2), |
1057 | "" ); |
1058 | } // namespace test_find_last_of_overload1 |
1059 | |
1060 | namespace test_find_last_of_overload2 { |
1061 | static_assert(string_view::npos == string_view("" ).find_last_of('a'), "" ); |
1062 | static_assert(0 == string_view("a" ).find_last_of('a'), "" ); |
1063 | static_assert(0 == string_view("abc" ).find_last_of('a'), "" ); |
1064 | static_assert(0 == string_view("a" ).find_last_of('a', 0), "" ); |
1065 | static_assert(1 == string_view("abc" ).find_last_of('b'), "" ); |
1066 | static_assert(string_view::npos == string_view("abc" ).find_last_of('b', 0), "" ); |
1067 | static_assert(1 == string_view("abc" ).find_last_of('b', 1), "" ); |
1068 | static_assert(2 == string_view("abc" ).find_last_of('c'), "" ); |
1069 | static_assert(string_view::npos == string_view("abc" ).find_last_of('c', 0), "" ); |
1070 | static_assert(string_view::npos == string_view("abc" ).find_last_of('c', 1), "" ); |
1071 | static_assert(2 == string_view("abc" ).find_last_of('c', 2), "" ); |
1072 | static_assert(2 == string_view("abc" ).find_last_of('c', 3), "" ); |
1073 | static_assert(0 == string_view("abc" ).find_last_of('a', 100), "" ); |
1074 | static_assert(string_view::npos == string_view("abc" ).find_last_of('z'), "" ); |
1075 | static_assert(4 == string_view("ababa" ).find_last_of('a'), "" ); |
1076 | static_assert(0 == string_view("ababa" ).find_last_of('a', 0), "" ); |
1077 | static_assert(0 == string_view("ababa" ).find_last_of('a', 1), "" ); |
1078 | static_assert(2 == string_view("ababa" ).find_last_of('a', 2), "" ); |
1079 | static_assert(2 == string_view("ababa" ).find_last_of('a', 3), "" ); |
1080 | static_assert(4 == string_view("ababa" ).find_last_of('a', 4), "" ); |
1081 | static_assert(4 == string_view("ababa" ).find_last_of('a', 5), "" ); |
1082 | } // namespace test_find_last_of_overload2 |
1083 | |
1084 | namespace test_find_last_of_overload3 { |
1085 | static_assert( |
1086 | string_view::npos == |
1087 | string_view("" ).find_last_of("ab" , string_view::npos, 0), |
1088 | "" ); |
1089 | static_assert( |
1090 | string_view::npos == |
1091 | string_view("" ).find_last_of("abc" , string_view::npos, 1), |
1092 | "" ); |
1093 | static_assert( |
1094 | string_view::npos == |
1095 | string_view("" ).find_last_of("abcdef" , string_view::npos, 3), |
1096 | "" ); |
1097 | static_assert( |
1098 | string_view::npos == |
1099 | string_view("abc" ).find_last_of("abcdef" , string_view::npos, 0), |
1100 | "" ); |
1101 | static_assert( |
1102 | string_view::npos == |
1103 | string_view("abc" ).find_last_of("defa" , string_view::npos, 1), |
1104 | "" ); |
1105 | static_assert( |
1106 | string_view::npos == |
1107 | string_view("abc" ).find_last_of("defcba" , string_view::npos, 3), |
1108 | "" ); |
1109 | |
1110 | static_assert( |
1111 | 3 == string_view("abcabc" ).find_last_of("abc" , string_view::npos, 1), |
1112 | "" ); |
1113 | static_assert( |
1114 | 4 == string_view("abcabc" ).find_last_of("bca" , string_view::npos, 1), |
1115 | "" ); |
1116 | static_assert( |
1117 | 5 == string_view("abcabc" ).find_last_of("cab" , string_view::npos, 1), |
1118 | "" ); |
1119 | static_assert( |
1120 | 5 == string_view("abcabc" ).find_last_of("bcab" , string_view::npos, 2), |
1121 | "" ); |
1122 | static_assert( |
1123 | 5 == string_view("abcabc" ).find_last_of("cbdac" , string_view::npos, 3), |
1124 | "" ); |
1125 | |
1126 | static_assert( |
1127 | string_view::npos == string_view("" ).find_last_of("ab" , 1, 0), |
1128 | "" ); |
1129 | static_assert( |
1130 | string_view::npos == string_view("" ).find_last_of("abc" , 0, 1), |
1131 | "" ); |
1132 | static_assert( |
1133 | string_view::npos == string_view("" ).find_last_of("abcdef" , 100, 3), |
1134 | "" ); |
1135 | static_assert( |
1136 | string_view::npos == string_view("abc" ).find_last_of("abcdef" , 1, 0), |
1137 | "" ); |
1138 | static_assert( |
1139 | string_view::npos == string_view("abc" ).find_last_of("defa" , 3, 1), |
1140 | "" ); |
1141 | static_assert( |
1142 | string_view::npos == string_view("abc" ).find_last_of("defcba" , 2, 3), |
1143 | "" ); |
1144 | |
1145 | static_assert(0 == string_view("abcabc" ).find_last_of("abc" , 2, 1), "" ); |
1146 | static_assert(1 == string_view("abcabc" ).find_last_of("bca" , 3, 1), "" ); |
1147 | static_assert(2 == string_view("abcabc" ).find_last_of("cab" , 2, 1), "" ); |
1148 | static_assert(2 == string_view("abcabc" ).find_last_of("bcab" , 3, 2), "" ); |
1149 | static_assert(2 == string_view("abcabc" ).find_last_of("cbdac" , 2, 2), "" ); |
1150 | } // namespace test_find_last_of_overload3 |
1151 | |
1152 | namespace test_find_last_of_overload4 { |
1153 | static_assert(string_view::npos == string_view("" ).find_last_of("" ), "" ); |
1154 | static_assert(string_view::npos == string_view("" ).find_last_of("a" ), "" ); |
1155 | static_assert(string_view::npos == string_view("" ).find_last_of("abc" ), "" ); |
1156 | static_assert(string_view::npos == string_view("abc" ).find_last_of("" ), "" ); |
1157 | static_assert(string_view::npos == string_view("abc" ).find_last_of("d" ), "" ); |
1158 | static_assert(string_view::npos == string_view("abc" ).find_last_of("def" ), "" ); |
1159 | |
1160 | static_assert(3 == string_view("abcabc" ).find_last_of("a" ), "" ); |
1161 | static_assert(4 == string_view("abcabc" ).find_last_of("b" ), "" ); |
1162 | static_assert(5 == string_view("abcabc" ).find_last_of("c" ), "" ); |
1163 | static_assert(5 == string_view("abcabc" ).find_last_of("bc" ), "" ); |
1164 | static_assert(5 == string_view("abcabc" ).find_last_of("cbd" ), "" ); |
1165 | |
1166 | static_assert(string_view::npos == string_view("" ).find_last_of("" , 1), "" ); |
1167 | static_assert(string_view::npos == string_view("" ).find_last_of("a" , 0), "" ); |
1168 | static_assert( |
1169 | string_view::npos == string_view("" ).find_last_of("abc" , 100), |
1170 | "" ); |
1171 | static_assert(string_view::npos == string_view("abc" ).find_last_of("" , 1), "" ); |
1172 | static_assert(string_view::npos == string_view("abc" ).find_last_of("d" , 3), "" ); |
1173 | static_assert( |
1174 | string_view::npos == string_view("abc" ).find_last_of("def" , 2), |
1175 | "" ); |
1176 | |
1177 | static_assert(0 == string_view("abcabc" ).find_last_of("a" , 2), "" ); |
1178 | static_assert(1 == string_view("abcabc" ).find_last_of("b" , 3), "" ); |
1179 | static_assert(2 == string_view("abcabc" ).find_last_of("c" , 2), "" ); |
1180 | static_assert(2 == string_view("abcabc" ).find_last_of("bc" , 3), "" ); |
1181 | static_assert(2 == string_view("abcabc" ).find_last_of("cbd" , 2), "" ); |
1182 | } // namespace test_find_last_of_overload4 |
1183 | |
1184 | namespace test_find_first_not_of_overload1 { |
1185 | static_assert( |
1186 | string_view::npos == string_view("" ).find_first_not_of(string_view("" )), |
1187 | "" ); |
1188 | static_assert( |
1189 | string_view::npos == string_view("" ).find_first_not_of(string_view("a" )), |
1190 | "" ); |
1191 | static_assert( |
1192 | string_view::npos == string_view("" ).find_first_not_of(string_view("abc" )), |
1193 | "" ); |
1194 | static_assert( |
1195 | string_view::npos == |
1196 | string_view("abc" ).find_first_not_of(string_view("abc" )), |
1197 | "" ); |
1198 | static_assert( |
1199 | string_view::npos == |
1200 | string_view("abc" ).find_first_not_of(string_view("acdb" )), |
1201 | "" ); |
1202 | static_assert( |
1203 | string_view::npos == |
1204 | string_view("abc" ).find_first_not_of(string_view("defabc" )), |
1205 | "" ); |
1206 | |
1207 | static_assert( |
1208 | 0 == string_view("abcabc" ).find_first_not_of(string_view("" )), |
1209 | "" ); |
1210 | static_assert( |
1211 | 0 == string_view("abcabc" ).find_first_not_of(string_view("bc" )), |
1212 | "" ); |
1213 | static_assert( |
1214 | 1 == string_view("abcabc" ).find_first_not_of(string_view("ac" )), |
1215 | "" ); |
1216 | static_assert( |
1217 | 2 == string_view("abcabc" ).find_first_not_of(string_view("ab" )), |
1218 | "" ); |
1219 | static_assert( |
1220 | 1 == string_view("abcabc" ).find_first_not_of(string_view("a" )), |
1221 | "" ); |
1222 | static_assert( |
1223 | 1 == string_view("abcabc" ).find_first_not_of(string_view("da" )), |
1224 | "" ); |
1225 | |
1226 | static_assert( |
1227 | string_view::npos == string_view("" ).find_first_not_of(string_view("" ), 1), |
1228 | "" ); |
1229 | static_assert( |
1230 | string_view::npos == string_view("" ).find_first_not_of(string_view("a" ), 1), |
1231 | "" ); |
1232 | static_assert( |
1233 | string_view::npos == |
1234 | string_view("" ).find_first_not_of(string_view("abc" ), 100), |
1235 | "" ); |
1236 | static_assert( |
1237 | string_view::npos == |
1238 | string_view("abc" ).find_first_not_of(string_view("abc" ), 1), |
1239 | "" ); |
1240 | static_assert( |
1241 | string_view::npos == |
1242 | string_view("abc" ).find_first_not_of(string_view("acdb" ), 3), |
1243 | "" ); |
1244 | static_assert( |
1245 | string_view::npos == |
1246 | string_view("abc" ).find_first_not_of(string_view("defabc" ), 2), |
1247 | "" ); |
1248 | |
1249 | static_assert( |
1250 | 1 == string_view("abcabc" ).find_first_not_of(string_view("" ), 1), |
1251 | "" ); |
1252 | static_assert( |
1253 | 3 == string_view("abcabc" ).find_first_not_of(string_view("bc" ), 1), |
1254 | "" ); |
1255 | static_assert( |
1256 | 4 == string_view("abcabc" ).find_first_not_of(string_view("ac" ), 4), |
1257 | "" ); |
1258 | static_assert( |
1259 | 5 == string_view("abcabc" ).find_first_not_of(string_view("ab" ), 5), |
1260 | "" ); |
1261 | static_assert( |
1262 | 4 == string_view("abcabc" ).find_first_not_of(string_view("a" ), 3), |
1263 | "" ); |
1264 | static_assert( |
1265 | 4 == string_view("abcabc" ).find_first_not_of(string_view("da" ), 4), |
1266 | "" ); |
1267 | } // namespace test_find_first_not_of_overload1 |
1268 | |
1269 | namespace test_find_first_not_of_overload2 { |
1270 | static_assert(string_view::npos == string_view("" ).find_first_not_of('a'), "" ); |
1271 | static_assert(string_view::npos == string_view("a" ).find_first_not_of('a'), "" ); |
1272 | static_assert(1 == string_view("abc" ).find_first_not_of('a'), "" ); |
1273 | static_assert( |
1274 | string_view::npos == string_view("a" ).find_first_not_of('a', 1), |
1275 | "" ); |
1276 | static_assert(0 == string_view("abc" ).find_first_not_of('b'), "" ); |
1277 | static_assert(2 == string_view("abc" ).find_first_not_of('b', 1), "" ); |
1278 | static_assert(2 == string_view("abc" ).find_first_not_of('b', 2), "" ); |
1279 | static_assert( |
1280 | string_view::npos == string_view("abc" ).find_first_not_of('b', 3), |
1281 | "" ); |
1282 | static_assert(0 == string_view("abc" ).find_first_not_of('c'), "" ); |
1283 | static_assert(1 == string_view("abc" ).find_first_not_of('c', 1), "" ); |
1284 | static_assert( |
1285 | string_view::npos == string_view("abc" ).find_first_not_of('c', 2), |
1286 | "" ); |
1287 | static_assert( |
1288 | string_view::npos == string_view("abc" ).find_first_not_of('c', 3), |
1289 | "" ); |
1290 | static_assert( |
1291 | string_view::npos == string_view("abc" ).find_first_not_of('a', 100), |
1292 | "" ); |
1293 | static_assert(1 == string_view("ababa" ).find_first_not_of('a'), "" ); |
1294 | static_assert(1 == string_view("ababa" ).find_first_not_of('a', 0), "" ); |
1295 | static_assert(1 == string_view("ababa" ).find_first_not_of('a', 1), "" ); |
1296 | static_assert(3 == string_view("ababa" ).find_first_not_of('a', 2), "" ); |
1297 | static_assert(3 == string_view("ababa" ).find_first_not_of('a', 3), "" ); |
1298 | static_assert( |
1299 | string_view::npos == string_view("ababa" ).find_first_not_of('a', 4), |
1300 | "" ); |
1301 | static_assert( |
1302 | string_view::npos == string_view("ababa" ).find_first_not_of('a', 5), |
1303 | "" ); |
1304 | } // namespace test_find_first_not_of_overload2 |
1305 | |
1306 | namespace test_find_first_not_of_overload3 { |
1307 | static_assert( |
1308 | string_view::npos == string_view("" ).find_first_not_of("ab" , 0, 0), |
1309 | "" ); |
1310 | static_assert( |
1311 | string_view::npos == string_view("" ).find_first_not_of("abc" , 0, 1), |
1312 | "" ); |
1313 | static_assert( |
1314 | string_view::npos == string_view("" ).find_first_not_of("abcdef" , 0, 3), |
1315 | "" ); |
1316 | static_assert( |
1317 | string_view::npos == string_view("abc" ).find_first_not_of("abcdef" , 0, 3), |
1318 | "" ); |
1319 | static_assert( |
1320 | string_view::npos == string_view("abc" ).find_first_not_of("acdbef" , 0, 4), |
1321 | "" ); |
1322 | static_assert( |
1323 | string_view::npos == string_view("abc" ).find_first_not_of("defabcas" , 0, 6), |
1324 | "" ); |
1325 | |
1326 | static_assert(0 == string_view("abcabc" ).find_first_not_of("abc" , 0, 0), "" ); |
1327 | static_assert(0 == string_view("abcabc" ).find_first_not_of("bca" , 0, 2), "" ); |
1328 | static_assert(1 == string_view("abcabc" ).find_first_not_of("acb" , 0, 2), "" ); |
1329 | static_assert(2 == string_view("abcabc" ).find_first_not_of("abc" , 0, 2), "" ); |
1330 | static_assert(1 == string_view("abcabc" ).find_first_not_of("abac" , 0, 1), "" ); |
1331 | static_assert(1 == string_view("abcabc" ).find_first_not_of("dadab" , 0, 2), "" ); |
1332 | |
1333 | static_assert( |
1334 | string_view::npos == string_view("" ).find_first_not_of("ab" , 1, 0), |
1335 | "" ); |
1336 | static_assert( |
1337 | string_view::npos == string_view("" ).find_first_not_of("abc" , 1, 1), |
1338 | "" ); |
1339 | static_assert( |
1340 | string_view::npos == string_view("" ).find_first_not_of("abcdef" , 100, 3), |
1341 | "" ); |
1342 | static_assert( |
1343 | string_view::npos == string_view("abc" ).find_first_not_of("abcdef" , 1, 3), |
1344 | "" ); |
1345 | static_assert( |
1346 | string_view::npos == string_view("abc" ).find_first_not_of("acdbef" , 3, 4), |
1347 | "" ); |
1348 | static_assert( |
1349 | string_view::npos == string_view("abc" ).find_first_not_of("defabcas" , 2, 6), |
1350 | "" ); |
1351 | |
1352 | static_assert(1 == string_view("abcabc" ).find_first_not_of("bca" , 1, 0), "" ); |
1353 | static_assert(3 == string_view("abcabc" ).find_first_not_of("bca" , 1, 2), "" ); |
1354 | static_assert(4 == string_view("abcabc" ).find_first_not_of("acb" , 4, 2), "" ); |
1355 | static_assert(5 == string_view("abcabc" ).find_first_not_of("abc" , 5, 2), "" ); |
1356 | static_assert(4 == string_view("abcabc" ).find_first_not_of("abac" , 3, 1), "" ); |
1357 | static_assert(4 == string_view("abcabc" ).find_first_not_of("dadab" , 4, 2), "" ); |
1358 | } // namespace test_find_first_not_of_overload3 |
1359 | |
1360 | namespace test_find_first_not_of_overload4 { |
1361 | static_assert(string_view::npos == string_view("" ).find_first_not_of("" ), "" ); |
1362 | static_assert(string_view::npos == string_view("" ).find_first_not_of("a" ), "" ); |
1363 | static_assert( |
1364 | string_view::npos == string_view("" ).find_first_not_of("abc" ), |
1365 | "" ); |
1366 | static_assert( |
1367 | string_view::npos == string_view("abc" ).find_first_not_of("abc" ), |
1368 | "" ); |
1369 | static_assert( |
1370 | string_view::npos == string_view("abc" ).find_first_not_of("acdb" ), |
1371 | "" ); |
1372 | static_assert( |
1373 | string_view::npos == string_view("abc" ).find_first_not_of("defabc" ), |
1374 | "" ); |
1375 | |
1376 | static_assert(0 == string_view("abcabc" ).find_first_not_of("" ), "" ); |
1377 | static_assert(0 == string_view("abcabc" ).find_first_not_of("bc" ), "" ); |
1378 | static_assert(1 == string_view("abcabc" ).find_first_not_of("ac" ), "" ); |
1379 | static_assert(2 == string_view("abcabc" ).find_first_not_of("ab" ), "" ); |
1380 | static_assert(1 == string_view("abcabc" ).find_first_not_of("a" ), "" ); |
1381 | static_assert(1 == string_view("abcabc" ).find_first_not_of("da" ), "" ); |
1382 | |
1383 | static_assert( |
1384 | string_view::npos == string_view("" ).find_first_not_of("" , 1), |
1385 | "" ); |
1386 | static_assert( |
1387 | string_view::npos == string_view("" ).find_first_not_of("a" , 1), |
1388 | "" ); |
1389 | static_assert( |
1390 | string_view::npos == string_view("" ).find_first_not_of("abc" , 100), |
1391 | "" ); |
1392 | static_assert( |
1393 | string_view::npos == string_view("abc" ).find_first_not_of("abc" , 1), |
1394 | "" ); |
1395 | static_assert( |
1396 | string_view::npos == string_view("abc" ).find_first_not_of("acdb" , 3), |
1397 | "" ); |
1398 | static_assert( |
1399 | string_view::npos == string_view("abc" ).find_first_not_of("defabc" , 2), |
1400 | "" ); |
1401 | |
1402 | static_assert(1 == string_view("abcabc" ).find_first_not_of("" , 1), "" ); |
1403 | static_assert(3 == string_view("abcabc" ).find_first_not_of("bc" , 1), "" ); |
1404 | static_assert(4 == string_view("abcabc" ).find_first_not_of("ac" , 4), "" ); |
1405 | static_assert(5 == string_view("abcabc" ).find_first_not_of("ab" , 5), "" ); |
1406 | static_assert(4 == string_view("abcabc" ).find_first_not_of("a" , 3), "" ); |
1407 | static_assert(4 == string_view("abcabc" ).find_first_not_of("da" , 4), "" ); |
1408 | } // namespace test_find_first_not_of_overload4 |
1409 | |
1410 | namespace test_find_last_not_of_overload1 { |
1411 | static_assert( |
1412 | string_view::npos == string_view("" ).find_last_not_of(string_view("" )), |
1413 | "" ); |
1414 | static_assert( |
1415 | string_view::npos == string_view("" ).find_last_not_of(string_view("a" )), |
1416 | "" ); |
1417 | static_assert( |
1418 | string_view::npos == string_view("" ).find_last_not_of(string_view("abc" )), |
1419 | "" ); |
1420 | static_assert( |
1421 | string_view::npos == |
1422 | string_view("abc" ).find_last_not_of(string_view("abc" )), |
1423 | "" ); |
1424 | static_assert( |
1425 | string_view::npos == |
1426 | string_view("abc" ).find_last_not_of(string_view("acdb" )), |
1427 | "" ); |
1428 | static_assert( |
1429 | string_view::npos == |
1430 | string_view("abc" ).find_last_not_of(string_view("defabc" )), |
1431 | "" ); |
1432 | |
1433 | static_assert(5 == string_view("abcabc" ).find_last_not_of(string_view("" )), "" ); |
1434 | static_assert( |
1435 | 3 == string_view("abcabc" ).find_last_not_of(string_view("bc" )), |
1436 | "" ); |
1437 | static_assert( |
1438 | 4 == string_view("abcabc" ).find_last_not_of(string_view("ac" )), |
1439 | "" ); |
1440 | static_assert( |
1441 | 5 == string_view("abcabc" ).find_last_not_of(string_view("ab" )), |
1442 | "" ); |
1443 | static_assert( |
1444 | 4 == string_view("abcabc" ).find_last_not_of(string_view("c" )), |
1445 | "" ); |
1446 | static_assert( |
1447 | 4 == string_view("abcabc" ).find_last_not_of(string_view("ca" )), |
1448 | "" ); |
1449 | |
1450 | static_assert( |
1451 | string_view::npos == string_view("" ).find_last_not_of(string_view("" ), 1), |
1452 | "" ); |
1453 | static_assert( |
1454 | string_view::npos == string_view("" ).find_last_not_of(string_view("a" ), 0), |
1455 | "" ); |
1456 | static_assert( |
1457 | string_view::npos == |
1458 | string_view("" ).find_last_not_of(string_view("abc" ), 100), |
1459 | "" ); |
1460 | static_assert( |
1461 | string_view::npos == |
1462 | string_view("abc" ).find_last_not_of(string_view("abc" ), 1), |
1463 | "" ); |
1464 | static_assert( |
1465 | string_view::npos == |
1466 | string_view("abc" ).find_last_not_of(string_view("acdb" ), 3), |
1467 | "" ); |
1468 | static_assert( |
1469 | string_view::npos == |
1470 | string_view("abc" ).find_last_not_of(string_view("defabc" ), 2), |
1471 | "" ); |
1472 | |
1473 | static_assert( |
1474 | 4 == string_view("abcabc" ).find_last_not_of(string_view("" ), 4), |
1475 | "" ); |
1476 | static_assert( |
1477 | 0 == string_view("abcabc" ).find_last_not_of(string_view("bc" ), 2), |
1478 | "" ); |
1479 | static_assert( |
1480 | 1 == string_view("abcabc" ).find_last_not_of(string_view("ac" ), 2), |
1481 | "" ); |
1482 | static_assert( |
1483 | 2 == string_view("abcabc" ).find_last_not_of(string_view("ab" ), 2), |
1484 | "" ); |
1485 | static_assert( |
1486 | 4 == string_view("abcabc" ).find_last_not_of(string_view("c" ), 4), |
1487 | "" ); |
1488 | static_assert( |
1489 | 1 == string_view("abcabc" ).find_last_not_of(string_view("ca" ), 2), |
1490 | "" ); |
1491 | } // namespace test_find_last_not_of_overload1 |
1492 | |
1493 | namespace test_find_last_not_of_overload2 { |
1494 | static_assert(string_view::npos == string_view("" ).find_last_not_of('a'), "" ); |
1495 | static_assert(string_view::npos == string_view("a" ).find_last_not_of('a'), "" ); |
1496 | static_assert(2 == string_view("abc" ).find_last_not_of('a'), "" ); |
1497 | static_assert(1 == string_view("abc" ).find_last_not_of('c'), "" ); |
1498 | static_assert( |
1499 | string_view::npos == string_view("a" ).find_last_not_of('a', 0), |
1500 | "" ); |
1501 | static_assert(2 == string_view("abc" ).find_last_not_of('b'), "" ); |
1502 | static_assert( |
1503 | string_view::npos == string_view("abc" ).find_last_not_of('a', 0), |
1504 | "" ); |
1505 | static_assert(0 == string_view("abc" ).find_last_not_of('b', 1), "" ); |
1506 | static_assert(0 == string_view("abc" ).find_last_not_of('c', 0), "" ); |
1507 | static_assert(1 == string_view("abc" ).find_last_not_of('c', 1), "" ); |
1508 | static_assert(1 == string_view("abc" ).find_last_not_of('c', 2), "" ); |
1509 | static_assert(1 == string_view("abc" ).find_last_not_of('c', 3), "" ); |
1510 | static_assert(2 == string_view("abc" ).find_last_not_of('a', 100), "" ); |
1511 | static_assert(3 == string_view("ababa" ).find_last_not_of('a'), "" ); |
1512 | static_assert( |
1513 | string_view::npos == string_view("ababa" ).find_last_not_of('a', 0), |
1514 | "" ); |
1515 | static_assert(1 == string_view("ababa" ).find_last_not_of('a', 1), "" ); |
1516 | static_assert(1 == string_view("ababa" ).find_last_not_of('a', 2), "" ); |
1517 | static_assert(3 == string_view("ababa" ).find_last_not_of('a', 3), "" ); |
1518 | static_assert(3 == string_view("ababa" ).find_last_not_of('a', 4), "" ); |
1519 | static_assert(3 == string_view("ababa" ).find_last_not_of('a', 5), "" ); |
1520 | } // namespace test_find_last_not_of_overload2 |
1521 | |
1522 | namespace test_find_last_not_of_overload3 { |
1523 | static_assert( |
1524 | string_view::npos == |
1525 | string_view("" ).find_last_not_of("ab" , string_view::npos, 0), |
1526 | "" ); |
1527 | static_assert( |
1528 | string_view::npos == |
1529 | string_view("" ).find_last_not_of("abc" , string_view::npos, 1), |
1530 | "" ); |
1531 | static_assert( |
1532 | string_view::npos == |
1533 | string_view("" ).find_last_not_of("abcdef" , string_view::npos, 3), |
1534 | "" ); |
1535 | static_assert( |
1536 | string_view::npos == |
1537 | string_view("abc" ).find_last_not_of("abcdef" , string_view::npos, 3), |
1538 | "" ); |
1539 | static_assert( |
1540 | string_view::npos == |
1541 | string_view("abc" ).find_last_not_of("acdbef" , string_view::npos, 4), |
1542 | "" ); |
1543 | static_assert( |
1544 | string_view::npos == |
1545 | string_view("abc" ).find_last_not_of("defabcas" , string_view::npos, 6), |
1546 | "" ); |
1547 | |
1548 | static_assert( |
1549 | 5 == string_view("abcabc" ).find_last_not_of("cab" , string_view::npos, 0), |
1550 | "" ); |
1551 | static_assert( |
1552 | 3 == string_view("abcabc" ).find_last_not_of("bca" , string_view::npos, 2), |
1553 | "" ); |
1554 | static_assert( |
1555 | 4 == string_view("abcabc" ).find_last_not_of("acb" , string_view::npos, 2), |
1556 | "" ); |
1557 | static_assert( |
1558 | 5 == string_view("abcabc" ).find_last_not_of("abc" , string_view::npos, 2), |
1559 | "" ); |
1560 | static_assert( |
1561 | 4 == string_view("abcabc" ).find_last_not_of("caba" , string_view::npos, 1), |
1562 | "" ); |
1563 | static_assert( |
1564 | 4 == string_view("abcabc" ).find_last_not_of("cacab" , string_view::npos, 2), |
1565 | "" ); |
1566 | |
1567 | static_assert( |
1568 | string_view::npos == string_view("" ).find_last_not_of("ab" , 1, 0), |
1569 | "" ); |
1570 | static_assert( |
1571 | string_view::npos == string_view("" ).find_last_not_of("abc" , 0, 1), |
1572 | "" ); |
1573 | static_assert( |
1574 | string_view::npos == string_view("" ).find_last_not_of("abcdef" , 100, 3), |
1575 | "" ); |
1576 | static_assert( |
1577 | string_view::npos == string_view("abc" ).find_last_not_of("abcdef" , 1, 3), |
1578 | "" ); |
1579 | static_assert( |
1580 | string_view::npos == string_view("abc" ).find_last_not_of("acdbef" , 3, 4), |
1581 | "" ); |
1582 | static_assert( |
1583 | string_view::npos == string_view("abc" ).find_last_not_of("defabcas" , 2, 6), |
1584 | "" ); |
1585 | |
1586 | static_assert(4 == string_view("abcabc" ).find_last_not_of("bca" , 4, 0), "" ); |
1587 | static_assert(0 == string_view("abcabc" ).find_last_not_of("bca" , 2, 2), "" ); |
1588 | static_assert(1 == string_view("abcabc" ).find_last_not_of("acb" , 2, 2), "" ); |
1589 | static_assert(2 == string_view("abcabc" ).find_last_not_of("abc" , 2, 2), "" ); |
1590 | static_assert(4 == string_view("abcabc" ).find_last_not_of("caba" , 4, 1), "" ); |
1591 | static_assert(1 == string_view("abcabc" ).find_last_not_of("cacab" , 2, 2), "" ); |
1592 | } // namespace test_find_last_not_of_overload3 |
1593 | |
1594 | namespace test_find_last_not_of_overload4 { |
1595 | static_assert(string_view::npos == string_view("" ).find_last_not_of("" ), "" ); |
1596 | static_assert(string_view::npos == string_view("" ).find_last_not_of("a" ), "" ); |
1597 | static_assert(string_view::npos == string_view("" ).find_last_not_of("abc" ), "" ); |
1598 | static_assert( |
1599 | string_view::npos == string_view("abc" ).find_last_not_of("abc" ), |
1600 | "" ); |
1601 | static_assert( |
1602 | string_view::npos == string_view("abc" ).find_last_not_of("acdb" ), |
1603 | "" ); |
1604 | static_assert( |
1605 | string_view::npos == string_view("abc" ).find_last_not_of("defabc" ), |
1606 | "" ); |
1607 | |
1608 | static_assert(5 == string_view("abcabc" ).find_last_not_of("" ), "" ); |
1609 | static_assert(3 == string_view("abcabc" ).find_last_not_of("bc" ), "" ); |
1610 | static_assert(4 == string_view("abcabc" ).find_last_not_of("ac" ), "" ); |
1611 | static_assert(5 == string_view("abcabc" ).find_last_not_of("ab" ), "" ); |
1612 | static_assert(4 == string_view("abcabc" ).find_last_not_of("c" ), "" ); |
1613 | static_assert(4 == string_view("abcabc" ).find_last_not_of("ca" ), "" ); |
1614 | |
1615 | static_assert(string_view::npos == string_view("" ).find_last_not_of("" , 1), "" ); |
1616 | static_assert( |
1617 | string_view::npos == string_view("" ).find_last_not_of("a" , 0), |
1618 | "" ); |
1619 | static_assert( |
1620 | string_view::npos == string_view("" ).find_last_not_of("abc" , 100), |
1621 | "" ); |
1622 | static_assert( |
1623 | string_view::npos == string_view("abc" ).find_last_not_of("abc" , 1), |
1624 | "" ); |
1625 | static_assert( |
1626 | string_view::npos == string_view("abc" ).find_last_not_of("acdb" , 3), |
1627 | "" ); |
1628 | static_assert( |
1629 | string_view::npos == string_view("abc" ).find_last_not_of("defabc" , 2), |
1630 | "" ); |
1631 | |
1632 | static_assert(4 == string_view("abcabc" ).find_last_not_of("" , 4), "" ); |
1633 | static_assert(0 == string_view("abcabc" ).find_last_not_of("bc" , 2), "" ); |
1634 | static_assert(1 == string_view("abcabc" ).find_last_not_of("ac" , 2), "" ); |
1635 | static_assert(2 == string_view("abcabc" ).find_last_not_of("ab" , 2), "" ); |
1636 | static_assert(4 == string_view("abcabc" ).find_last_not_of("c" , 4), "" ); |
1637 | static_assert(1 == string_view("abcabc" ).find_last_not_of("ca" , 2), "" ); |
1638 | } // namespace test_find_last_not_of_overload4 |
1639 | |
1640 | namespace test_output_operator { |
1641 | void testOutputIterator(const std::string& str) { |
1642 | std::ostringstream stream; |
1643 | stream << string_view(str); |
1644 | std::string actual = stream.str(); |
1645 | EXPECT_EQ(str, actual); |
1646 | } |
1647 | |
1648 | TEST(StringViewTest, testOutputOperator) { |
1649 | testOutputIterator("" ); |
1650 | testOutputIterator("abc" ); |
1651 | } |
1652 | } // namespace test_output_operator |
1653 | |
1654 | namespace test_hash { |
1655 | TEST(StringViewTest, testHash) { |
1656 | EXPECT_EQ( |
1657 | std::hash<string_view>()(string_view()), std::hash<string_view>()("" )); |
1658 | EXPECT_EQ( |
1659 | std::hash<string_view>()(string_view("hello" )), |
1660 | std::hash<string_view>()("hello" )); |
1661 | EXPECT_NE( |
1662 | std::hash<string_view>()(string_view("hello" )), |
1663 | std::hash<string_view>()("" )); |
1664 | } |
1665 | } // namespace test_hash |
1666 | |
1667 | } // namespace |
1668 | |