24 EXPECT_EQ(
'a', abc
[0
]);
25 EXPECT_EQ(
'b', abc
[1
]);
26 EXPECT_EQ(
'c', abc
[2
]);
28 EXPECT_DEATH({ abc
[3
]; },
"");
31 pdfium::span<
const char> abc_span = abc.span();
32 EXPECT_EQ(3u, abc_span.size());
33 EXPECT_EQ(0, memcmp(abc_span.data(),
"abc", 3));
35 pdfium::span<
const uint8_t> abc_raw_span = abc.raw_span();
36 EXPECT_EQ(3u, abc_raw_span.size());
37 EXPECT_EQ(0, memcmp(abc_raw_span.data(),
"abc", 3));
41 EXPECT_EQ(
'a', mutable_abc
[0
]);
42 EXPECT_EQ(
'b', mutable_abc
[1
]);
43 EXPECT_EQ(
'c', mutable_abc
[2
]);
45 EXPECT_EQ(
"abc", abc);
48 mutable_abc.SetAt(0,
'd');
50 EXPECT_NE(c_str, mutable_abc
.c_str());
51 EXPECT_EQ(
"abc", abc);
52 EXPECT_EQ(
"dbc", mutable_abc);
54 mutable_abc.SetAt(1,
'e');
55 EXPECT_EQ(
"abc", abc);
56 EXPECT_EQ(
"dec", mutable_abc);
58 mutable_abc.SetAt(2,
'f');
59 EXPECT_EQ(
"abc", abc);
60 EXPECT_EQ(
"def", mutable_abc);
62 EXPECT_DEATH({ mutable_abc.SetAt(3,
'g'); },
"");
63 EXPECT_EQ(
"abc", abc);
146 ByteStringView v_empty;
147 ByteStringView v_a(
"a");
148 ByteStringView v_abc(
"abc");
149 ByteStringView v_def(
"def");
150 const char*
const c_null =
nullptr;
151 const char*
const c_empty =
"";
152 const char*
const c_a =
"a";
153 const char*
const c_abc =
"abc";
154 const char*
const c_def =
"def";
156 EXPECT_FALSE(empty
< empty);
158 EXPECT_FALSE(abc
< abc);
159 EXPECT_FALSE(def
< def);
160 EXPECT_FALSE(c_null
< empty);
161 EXPECT_FALSE(c_empty
< empty);
162 EXPECT_FALSE(c_a
< a);
163 EXPECT_FALSE(c_abc
< abc);
164 EXPECT_FALSE(c_def
< def);
165 EXPECT_FALSE(empty
< c_null);
166 EXPECT_FALSE(empty
< c_empty);
167 EXPECT_FALSE(a
< c_a);
168 EXPECT_FALSE(abc
< c_abc);
169 EXPECT_FALSE(def
< c_def);
170 EXPECT_FALSE(empty < v_empty);
171 EXPECT_FALSE(a < v_a);
172 EXPECT_FALSE(abc < v_abc);
173 EXPECT_FALSE(def < v_def);
175 EXPECT_TRUE(empty
< a);
176 EXPECT_FALSE(a
< empty);
177 EXPECT_TRUE(c_null
< a);
178 EXPECT_TRUE(c_empty
< a);
179 EXPECT_FALSE(c_a
< empty);
180 EXPECT_TRUE(empty
< c_a);
181 EXPECT_FALSE(a
< c_null);
182 EXPECT_FALSE(a
< c_empty);
183 EXPECT_TRUE(empty < v_a);
184 EXPECT_FALSE(a < v_empty);
186 EXPECT_TRUE(empty
< abc);
187 EXPECT_FALSE(abc
< empty);
188 EXPECT_TRUE(c_null
< abc);
189 EXPECT_TRUE(c_empty
< abc);
190 EXPECT_FALSE(c_abc
< empty);
191 EXPECT_TRUE(empty
< c_abc);
192 EXPECT_FALSE(abc
< c_null);
193 EXPECT_FALSE(abc
< c_empty);
194 EXPECT_TRUE(empty < v_abc);
195 EXPECT_FALSE(abc < v_empty);
197 EXPECT_TRUE(empty
< def);
198 EXPECT_FALSE(def
< empty);
199 EXPECT_TRUE(c_null
< def);
200 EXPECT_TRUE(c_empty
< def);
201 EXPECT_FALSE(c_def
< empty);
202 EXPECT_TRUE(empty
< c_def);
203 EXPECT_FALSE(def
< c_null);
204 EXPECT_FALSE(def
< c_empty);
205 EXPECT_TRUE(empty < v_def);
206 EXPECT_FALSE(def < v_empty);
208 EXPECT_TRUE(a
< abc);
209 EXPECT_FALSE(abc
< a);
210 EXPECT_TRUE(c_a
< abc);
211 EXPECT_FALSE(c_abc
< a);
212 EXPECT_TRUE(a
< c_abc);
213 EXPECT_FALSE(abc
< c_a);
214 EXPECT_TRUE(a < v_abc);
215 EXPECT_FALSE(abc < v_a);
217 EXPECT_TRUE(a
< def);
218 EXPECT_FALSE(def
< a);
219 EXPECT_TRUE(c_a
< def);
220 EXPECT_FALSE(c_def
< a);
221 EXPECT_TRUE(a
< c_def);
222 EXPECT_FALSE(def
< c_a);
223 EXPECT_TRUE(a < v_def);
224 EXPECT_FALSE(def < v_a);
226 EXPECT_TRUE(abc
< def);
227 EXPECT_FALSE(def
< abc);
228 EXPECT_TRUE(c_abc
< def);
229 EXPECT_FALSE(c_def
< abc);
230 EXPECT_TRUE(abc
< c_def);
231 EXPECT_FALSE(def
< c_abc);
232 EXPECT_TRUE(abc < v_def);
233 EXPECT_FALSE(def < v_abc);
235 EXPECT_TRUE(v_empty < a);
236 EXPECT_TRUE(v_empty < c_a);
238 std::set<ByteString, std::less<>> str_set;
239 bool inserted = str_set.insert(
ByteString("hello")).second;
240 ASSERT_TRUE(inserted);
241 EXPECT_TRUE(pdfium::Contains(str_set,
ByteString("hello")));
242 EXPECT_TRUE(pdfium::Contains(str_set, ByteStringView(
"hello")));
243 EXPECT_TRUE(pdfium::Contains(str_set,
"hello"));
244 EXPECT_FALSE(pdfium::Contains(str_set,
ByteString("goodbye")));
245 EXPECT_FALSE(pdfium::Contains(str_set, ByteStringView(
"goodbye")));
246 EXPECT_FALSE(pdfium::Contains(str_set,
"goodbye"));
251 EXPECT_TRUE(null_string
== null_string);
254 EXPECT_TRUE(empty_string
== empty_string);
255 EXPECT_TRUE(empty_string
== null_string);
256 EXPECT_TRUE(null_string
== empty_string);
259 deleted_string.Delete(0, 5);
260 EXPECT_TRUE(deleted_string
== deleted_string);
261 EXPECT_TRUE(deleted_string
== null_string);
262 EXPECT_TRUE(deleted_string
== empty_string);
263 EXPECT_TRUE(null_string
== deleted_string);
264 EXPECT_TRUE(empty_string
== deleted_string);
267 EXPECT_TRUE(byte_string
== byte_string);
268 EXPECT_FALSE(byte_string
== null_string);
269 EXPECT_FALSE(byte_string
== empty_string);
270 EXPECT_FALSE(byte_string
== deleted_string);
271 EXPECT_FALSE(null_string
== byte_string);
272 EXPECT_FALSE(empty_string
== byte_string);
273 EXPECT_FALSE(deleted_string
== byte_string);
276 EXPECT_TRUE(byte_string
== byte_string_same1);
277 EXPECT_TRUE(byte_string_same1
== byte_string);
280 EXPECT_TRUE(byte_string
== byte_string_same2);
281 EXPECT_TRUE(byte_string_same2
== byte_string);
286 EXPECT_FALSE(byte_string
== byte_string1);
287 EXPECT_FALSE(byte_string
== byte_string2);
288 EXPECT_FALSE(byte_string
== byte_string3);
289 EXPECT_FALSE(byte_string1
== byte_string);
290 EXPECT_FALSE(byte_string2
== byte_string);
291 EXPECT_FALSE(byte_string3
== byte_string);
293 ByteStringView null_string_c;
294 ByteStringView empty_string_c(
"");
295 EXPECT_TRUE(null_string == null_string_c);
296 EXPECT_TRUE(null_string == empty_string_c);
297 EXPECT_TRUE(empty_string == null_string_c);
298 EXPECT_TRUE(empty_string == empty_string_c);
299 EXPECT_TRUE(deleted_string == null_string_c);
300 EXPECT_TRUE(deleted_string == empty_string_c);
301 EXPECT_TRUE(null_string_c == null_string);
302 EXPECT_TRUE(empty_string_c == null_string);
303 EXPECT_TRUE(null_string_c == empty_string);
304 EXPECT_TRUE(empty_string_c == empty_string);
305 EXPECT_TRUE(null_string_c == deleted_string);
306 EXPECT_TRUE(empty_string_c == deleted_string);
308 ByteStringView byte_string_c_same1(
"hello");
309 EXPECT_TRUE(byte_string == byte_string_c_same1);
310 EXPECT_TRUE(byte_string_c_same1 == byte_string);
312 ByteStringView byte_string_c1(
"he");
313 ByteStringView byte_string_c2(
"hellp");
314 ByteStringView byte_string_c3(
"hellod");
315 EXPECT_FALSE(byte_string == byte_string_c1);
316 EXPECT_FALSE(byte_string == byte_string_c2);
317 EXPECT_FALSE(byte_string == byte_string_c3);
318 EXPECT_FALSE(byte_string_c1 == byte_string);
319 EXPECT_FALSE(byte_string_c2 == byte_string);
320 EXPECT_FALSE(byte_string_c3 == byte_string);
322 const char*
const c_null_string =
nullptr;
323 const char*
const c_empty_string =
"";
324 EXPECT_TRUE(null_string
== c_null_string);
325 EXPECT_TRUE(null_string
== c_empty_string);
326 EXPECT_TRUE(empty_string
== c_null_string);
327 EXPECT_TRUE(empty_string
== c_empty_string);
328 EXPECT_TRUE(deleted_string
== c_null_string);
329 EXPECT_TRUE(deleted_string
== c_empty_string);
330 EXPECT_TRUE(c_null_string
== null_string);
331 EXPECT_TRUE(c_empty_string
== null_string);
332 EXPECT_TRUE(c_null_string
== empty_string);
333 EXPECT_TRUE(c_empty_string
== empty_string);
334 EXPECT_TRUE(c_null_string
== deleted_string);
335 EXPECT_TRUE(c_empty_string
== deleted_string);
337 const char*
const c_string_same1 =
"hello";
338 EXPECT_TRUE(byte_string
== c_string_same1);
339 EXPECT_TRUE(c_string_same1
== byte_string);
341 const char*
const c_string1 =
"he";
342 const char*
const c_string2 =
"hellp";
343 const char*
const c_string3 =
"hellod";
344 EXPECT_FALSE(byte_string
== c_string1);
345 EXPECT_FALSE(byte_string
== c_string2);
346 EXPECT_FALSE(byte_string
== c_string3);
347 EXPECT_FALSE(c_string1
== byte_string);
348 EXPECT_FALSE(c_string2
== byte_string);
349 EXPECT_FALSE(c_string3
== byte_string);
354 EXPECT_FALSE(null_string
!= null_string);
357 EXPECT_FALSE(empty_string
!= empty_string);
358 EXPECT_FALSE(empty_string
!= null_string);
359 EXPECT_FALSE(null_string
!= empty_string);
362 deleted_string.Delete(0, 5);
363 EXPECT_FALSE(deleted_string
!= deleted_string);
364 EXPECT_FALSE(deleted_string
!= null_string);
365 EXPECT_FALSE(deleted_string
!= empty_string);
366 EXPECT_FALSE(deleted_string
!= deleted_string);
367 EXPECT_FALSE(null_string
!= deleted_string);
368 EXPECT_FALSE(empty_string
!= deleted_string);
369 EXPECT_FALSE(deleted_string
!= deleted_string);
372 EXPECT_FALSE(byte_string
!= byte_string);
373 EXPECT_TRUE(byte_string
!= null_string);
374 EXPECT_TRUE(byte_string
!= empty_string);
375 EXPECT_TRUE(byte_string
!= deleted_string);
376 EXPECT_TRUE(null_string
!= byte_string);
377 EXPECT_TRUE(empty_string
!= byte_string);
378 EXPECT_TRUE(deleted_string
!= byte_string);
381 EXPECT_FALSE(byte_string
!= byte_string_same1);
382 EXPECT_FALSE(byte_string_same1
!= byte_string);
385 EXPECT_FALSE(byte_string
!= byte_string_same2);
386 EXPECT_FALSE(byte_string_same2
!= byte_string);
391 EXPECT_TRUE(byte_string
!= byte_string1);
392 EXPECT_TRUE(byte_string
!= byte_string2);
393 EXPECT_TRUE(byte_string
!= byte_string3);
394 EXPECT_TRUE(byte_string1
!= byte_string);
395 EXPECT_TRUE(byte_string2
!= byte_string);
396 EXPECT_TRUE(byte_string3
!= byte_string);
398 ByteStringView null_string_c;
399 ByteStringView empty_string_c(
"");
400 EXPECT_FALSE(null_string != null_string_c);
401 EXPECT_FALSE(null_string != empty_string_c);
402 EXPECT_FALSE(empty_string != null_string_c);
403 EXPECT_FALSE(empty_string != empty_string_c);
404 EXPECT_FALSE(null_string_c != null_string);
405 EXPECT_FALSE(empty_string_c != null_string);
406 EXPECT_FALSE(null_string_c != empty_string);
407 EXPECT_FALSE(empty_string_c != empty_string);
409 ByteStringView byte_string_c_same1(
"hello");
410 EXPECT_FALSE(byte_string != byte_string_c_same1);
411 EXPECT_FALSE(byte_string_c_same1 != byte_string);
413 ByteStringView byte_string_c1(
"he");
414 ByteStringView byte_string_c2(
"hellp");
415 ByteStringView byte_string_c3(
"hellod");
416 EXPECT_TRUE(byte_string != byte_string_c1);
417 EXPECT_TRUE(byte_string != byte_string_c2);
418 EXPECT_TRUE(byte_string != byte_string_c3);
419 EXPECT_TRUE(byte_string_c1 != byte_string);
420 EXPECT_TRUE(byte_string_c2 != byte_string);
421 EXPECT_TRUE(byte_string_c3 != byte_string);
423 const char*
const c_null_string =
nullptr;
424 const char*
const c_empty_string =
"";
425 EXPECT_FALSE(null_string
!= c_null_string);
426 EXPECT_FALSE(null_string
!= c_empty_string);
427 EXPECT_FALSE(empty_string
!= c_null_string);
428 EXPECT_FALSE(empty_string
!= c_empty_string);
429 EXPECT_FALSE(deleted_string
!= c_null_string);
430 EXPECT_FALSE(deleted_string
!= c_empty_string);
431 EXPECT_FALSE(c_null_string
!= null_string);
432 EXPECT_FALSE(c_empty_string
!= null_string);
433 EXPECT_FALSE(c_null_string
!= empty_string);
434 EXPECT_FALSE(c_empty_string
!= empty_string);
435 EXPECT_FALSE(c_null_string
!= deleted_string);
436 EXPECT_FALSE(c_empty_string
!= deleted_string);
438 const char*
const c_string_same1 =
"hello";
439 EXPECT_FALSE(byte_string
!= c_string_same1);
440 EXPECT_FALSE(c_string_same1
!= byte_string);
442 const char*
const c_string1 =
"he";
443 const char*
const c_string2 =
"hellp";
444 const char*
const c_string3 =
"hellod";
445 EXPECT_TRUE(byte_string
!= c_string1);
446 EXPECT_TRUE(byte_string
!= c_string2);
447 EXPECT_TRUE(byte_string
!= c_string3);
448 EXPECT_TRUE(c_string1
!= byte_string);
449 EXPECT_TRUE(c_string2
!= byte_string);
450 EXPECT_TRUE(c_string3
!= byte_string);
518 const char* old_buffer = freed
.c_str();
522 EXPECT_EQ(
"FREED", freed);
523 EXPECT_EQ(old_buffer, freed
.c_str());
527 EXPECT_EQ(
"FRD", freed);
528 EXPECT_EQ(old_buffer, freed
.c_str());
533 EXPECT_EQ(
"FRD", freed);
534 EXPECT_EQ(old_buffer, freed
.c_str());
535 EXPECT_EQ(old_buffer, shared
.c_str());
539 EXPECT_EQ(
"FR", freed);
540 EXPECT_NE(old_buffer, freed
.c_str());
541 EXPECT_EQ(
"FRD", shared);
542 EXPECT_EQ(old_buffer, shared
.c_str());
584 EXPECT_EQ(5u, fred.Insert(0,
'S'));
585 EXPECT_EQ(
"SFRED", fred);
586 EXPECT_EQ(6u, fred.Insert(1,
'T'));
587 EXPECT_EQ(
"STFRED", fred);
588 EXPECT_EQ(7u, fred.Insert(4,
'U'));
589 EXPECT_EQ(
"STFRUED", fred);
590 EXPECT_EQ(8u, fred.Insert(7,
'V'));
591 EXPECT_EQ(
"STFRUEDV", fred);
592 EXPECT_EQ(8u, fred.Insert(12,
'P'));
593 EXPECT_EQ(
"STFRUEDV", fred);
596 EXPECT_EQ(1u, empty.Insert(0,
'X'));
597 EXPECT_EQ(
"X", empty);
601 EXPECT_EQ(0u, empty.Insert(5,
'X'));
602 EXPECT_NE(
"X", empty);
609 EXPECT_EQ(1u, empty.InsertAtFront(
'D'));
610 EXPECT_EQ(
"D", empty);
611 EXPECT_EQ(2u, empty.InsertAtFront(
'E'));
612 EXPECT_EQ(
"ED", empty);
613 EXPECT_EQ(3u, empty.InsertAtFront(
'R'));
614 EXPECT_EQ(
"RED", empty);
615 EXPECT_EQ(4u, empty.InsertAtFront(
'F'));
616 EXPECT_EQ(
"FRED", empty);
620 EXPECT_EQ(1u, empty.InsertAtBack(
'F'));
621 EXPECT_EQ(
"F", empty);
622 EXPECT_EQ(2u, empty.InsertAtBack(
'R'));
623 EXPECT_EQ(
"FR", empty);
624 EXPECT_EQ(3u, empty.InsertAtBack(
'E'));
625 EXPECT_EQ(
"FRE", empty);
626 EXPECT_EQ(4u, empty.InsertAtBack(
'D'));
627 EXPECT_EQ(
"FRED", empty);
631 EXPECT_EQ(1u, empty.InsertAtBack(
'E'));
632 EXPECT_EQ(
"E", empty);
633 EXPECT_EQ(2u, empty.InsertAtFront(
'R'));
634 EXPECT_EQ(
"RE", empty);
635 EXPECT_EQ(3u, empty.InsertAtBack(
'D'));
636 EXPECT_EQ(
"RED", empty);
637 EXPECT_EQ(4u, empty.InsertAtFront(
'F'));
638 EXPECT_EQ(
"FRED", empty);
644 EXPECT_EQ(4u, fred.Delete(0, 0));
645 EXPECT_EQ(
"FRED", fred);
646 EXPECT_EQ(2u, fred.Delete(0, 2));
647 EXPECT_EQ(
"ED", fred);
648 EXPECT_EQ(1u, fred.Delete(1));
649 EXPECT_EQ(
"E", fred);
650 EXPECT_EQ(0u, fred.Delete(0));
652 EXPECT_EQ(0u, fred.Delete(0));
656 EXPECT_EQ(0u, empty.Delete(0));
657 EXPECT_EQ(
"", empty);
658 EXPECT_EQ(0u, empty.Delete(1));
659 EXPECT_EQ(
"", empty);
730 EXPECT_FALSE(null_string.Find(
'a').has_value());
731 EXPECT_FALSE(null_string.Find(
'\0').has_value());
734 EXPECT_FALSE(empty_string.Find(
'a').has_value());
735 EXPECT_FALSE(empty_string.Find(
'\0').has_value());
738 absl::optional<size_t> result = single_string.Find(
'a');
739 ASSERT_TRUE(result.has_value());
740 EXPECT_EQ(0u, result.value());
741 EXPECT_FALSE(single_string.Find(
'b').has_value());
742 EXPECT_FALSE(single_string.Find(
'\0').has_value());
745 result = longer_string.Find(
'a');
746 ASSERT_TRUE(result.has_value());
747 EXPECT_EQ(0u, result.value());
748 result = longer_string.Find(
'c');
749 ASSERT_TRUE(result.has_value());
750 EXPECT_EQ(2u, result.value());
751 result = longer_string.Find(
'c', 3);
752 ASSERT_TRUE(result.has_value());
753 EXPECT_EQ(3u, result.value());
754 EXPECT_FALSE(longer_string.Find(
'd').has_value());
755 EXPECT_FALSE(longer_string.Find(
'\0').has_value());
757 result = longer_string.Find(
"ab");
758 ASSERT_TRUE(result.has_value());
759 EXPECT_EQ(0u, result.value());
760 result = longer_string.Find(
"ccc");
761 ASSERT_TRUE(result.has_value());
762 EXPECT_EQ(2u, result.value());
763 result = longer_string.Find(
"cc", 3);
764 ASSERT_TRUE(result.has_value());
765 EXPECT_EQ(3u, result.value());
766 EXPECT_FALSE(longer_string.Find(
"d").has_value());
771 result = hibyte_string.Find(
'\x8c');
772 ASSERT_TRUE(result.has_value());
773 EXPECT_EQ(2u, result.value());
778 EXPECT_FALSE(null_string.ReverseFind(
'a').has_value());
779 EXPECT_FALSE(null_string.ReverseFind(
'\0').has_value());
782 EXPECT_FALSE(empty_string.ReverseFind(
'a').has_value());
783 EXPECT_FALSE(empty_string.ReverseFind(
'\0').has_value());
786 absl::optional<size_t> result = single_string.ReverseFind(
'a');
787 ASSERT_TRUE(result.has_value());
788 EXPECT_EQ(0u, result.value());
789 EXPECT_FALSE(single_string.ReverseFind(
'b').has_value());
790 EXPECT_FALSE(single_string.ReverseFind(
'\0').has_value());
793 result = longer_string.ReverseFind(
'a');
794 ASSERT_TRUE(result.has_value());
795 EXPECT_EQ(0u, result.value());
796 result = longer_string.ReverseFind(
'c');
797 ASSERT_TRUE(result.has_value());
798 EXPECT_EQ(4u, result.value());
799 EXPECT_FALSE(longer_string.ReverseFind(
'\0').has_value());
804 result = hibyte_string.ReverseFind(
'\x8c');
805 ASSERT_TRUE(result.has_value());
806 EXPECT_EQ(2u, result.value());
1090 auto iter = multi_str.rbegin();
1091 EXPECT_NE(iter, multi_str.rend());
1092 EXPECT_EQ(4, multi_str.rend() - iter);
1093 EXPECT_EQ(0, iter - multi_str.rbegin());
1097 EXPECT_EQ(
'c', *iter);
1098 EXPECT_NE(iter, multi_str.rend());
1099 EXPECT_EQ(3, multi_str.rend() - iter);
1100 EXPECT_EQ(1, iter - multi_str.rbegin());
1104 EXPECT_EQ(
'b', *iter);
1105 EXPECT_NE(iter, multi_str.rend());
1106 EXPECT_EQ(2, multi_str.rend() - iter);
1107 EXPECT_EQ(2, iter - multi_str.rbegin());
1111 EXPECT_EQ(
'a', *iter);
1112 EXPECT_NE(iter, multi_str.rend());
1113 EXPECT_EQ(1, multi_str.rend() - iter);
1114 EXPECT_EQ(3, iter - multi_str.rbegin());
1118 EXPECT_EQ(iter, multi_str.rend());
1119 EXPECT_EQ(0, multi_str.rend() - iter);
1120 EXPECT_EQ(4, iter - multi_str.rbegin());
1124 EXPECT_EQ(
'a', *iter);
1125 EXPECT_NE(iter, multi_str.rend());
1126 EXPECT_EQ(1, multi_str.rend() - iter);
1127 EXPECT_EQ(3, iter - multi_str.rbegin());
1131 EXPECT_EQ(
'b', *iter);
1132 EXPECT_NE(iter, multi_str.rend());
1133 EXPECT_EQ(2, multi_str.rend() - iter);
1134 EXPECT_EQ(2, iter - multi_str.rbegin());
1138 EXPECT_EQ(
'c', *iter);
1139 EXPECT_NE(iter, multi_str.rend());
1140 EXPECT_EQ(3, multi_str.rend() - iter);
1141 EXPECT_EQ(1, iter - multi_str.rbegin());
1145 EXPECT_EQ(
'd', *iter);
1146 EXPECT_EQ(iter, multi_str.rbegin());
1147 EXPECT_EQ(4, multi_str.rend() - iter);
1148 EXPECT_EQ(0, iter - multi_str.rbegin());
1152 ByteStringView null_string;
1153 EXPECT_FALSE(null_string.raw_str());
1154 EXPECT_EQ(0u, null_string.GetLength());
1155 EXPECT_TRUE(null_string.IsEmpty());
1157 ByteStringView another_null_string;
1158 EXPECT_EQ(null_string, another_null_string);
1160 ByteStringView copied_null_string(null_string);
1161 EXPECT_FALSE(copied_null_string.raw_str());
1162 EXPECT_EQ(0u, copied_null_string.GetLength());
1163 EXPECT_TRUE(copied_null_string.IsEmpty());
1164 EXPECT_EQ(null_string, copied_null_string);
1166 ByteStringView span_null_string = pdfium::span<
const uint8_t>();
1167 EXPECT_FALSE(span_null_string.raw_str());
1168 EXPECT_EQ(0u, span_null_string.GetLength());
1169 EXPECT_TRUE(span_null_string.IsEmpty());
1170 EXPECT_EQ(null_string, span_null_string);
1172 ByteStringView empty_string(
"");
1173 EXPECT_TRUE(empty_string.raw_str());
1174 EXPECT_EQ(0u, empty_string.GetLength());
1175 EXPECT_TRUE(empty_string.IsEmpty());
1176 EXPECT_EQ(null_string, empty_string);
1178 ByteStringView assigned_null_string(
"initially not nullptr");
1179 assigned_null_string = null_string;
1180 EXPECT_FALSE(assigned_null_string.raw_str());
1181 EXPECT_EQ(0u, assigned_null_string.GetLength());
1182 EXPECT_TRUE(assigned_null_string.IsEmpty());
1183 EXPECT_EQ(null_string, assigned_null_string);
1185 ByteStringView assigned_nullptr_string(
"initially not nullptr");
1186 assigned_nullptr_string =
nullptr;
1187 EXPECT_FALSE(assigned_nullptr_string.raw_str());
1188 EXPECT_EQ(0u, assigned_nullptr_string.GetLength());
1189 EXPECT_TRUE(assigned_nullptr_string.IsEmpty());
1190 EXPECT_EQ(null_string, assigned_nullptr_string);
1192 ByteStringView assigned_span_null_string(
"initially not null span");
1193 assigned_span_null_string = pdfium::span<
const uint8_t>();
1194 EXPECT_FALSE(assigned_span_null_string.raw_str());
1195 EXPECT_EQ(0u, assigned_span_null_string.GetLength());
1196 EXPECT_TRUE(assigned_span_null_string.IsEmpty());
1197 EXPECT_EQ(null_string, assigned_span_null_string);
1199 ByteStringView non_null_string(
"a");
1200 EXPECT_NE(null_string, non_null_string);
1204 ByteStringView string3(
"abc");
1205 ByteStringView string6(
"abcdef");
1206 ByteStringView alternate_string3(
"abcdef", 3);
1207 ByteStringView span_string4(pdfium::as_bytes(pdfium::make_span(
"abcd", 4u)));
1208 ByteStringView embedded_nul_string7(
"abc\0def", 7);
1209 ByteStringView illegal_string7(
"abcdef", 7);
1211 EXPECT_EQ(3u, string3.GetLength());
1212 EXPECT_EQ(6u, string6.GetLength());
1213 EXPECT_EQ(3u, alternate_string3.GetLength());
1214 EXPECT_EQ(4u, span_string4.GetLength());
1215 EXPECT_EQ(7u, embedded_nul_string7.GetLength());
1216 EXPECT_EQ(7u, illegal_string7.GetLength());
1218 EXPECT_NE(string3, string6);
1219 EXPECT_EQ(string3, alternate_string3);
1220 EXPECT_NE(string3, embedded_nul_string7);
1221 EXPECT_NE(string3, illegal_string7);
1222 EXPECT_NE(string6, alternate_string3);
1223 EXPECT_NE(string6, embedded_nul_string7);
1224 EXPECT_NE(string6, illegal_string7);
1225 EXPECT_NE(alternate_string3, embedded_nul_string7);
1226 EXPECT_NE(alternate_string3, illegal_string7);
1227 EXPECT_NE(embedded_nul_string7, illegal_string7);
1229 ByteStringView copied_string3(string3);
1230 ByteStringView copied_alternate_string3(alternate_string3);
1231 ByteStringView copied_embedded_nul_string7(embedded_nul_string7);
1233 EXPECT_EQ(string3, copied_string3);
1234 EXPECT_EQ(alternate_string3, copied_alternate_string3);
1235 EXPECT_EQ(embedded_nul_string7, copied_embedded_nul_string7);
1237 ByteStringView assigned_string3(
"intially something else");
1238 ByteStringView assigned_alternate_string3(
"initally something else");
1239 ByteStringView assigned_ptr_string3(
"initially something else");
1240 ByteStringView assigned_embedded_nul_string7(
"initially something else");
1242 assigned_string3 = string3;
1243 assigned_alternate_string3 = alternate_string3;
1244 assigned_ptr_string3 =
"abc";
1245 assigned_embedded_nul_string7 = embedded_nul_string7;
1246 EXPECT_EQ(string3, assigned_string3);
1247 EXPECT_EQ(alternate_string3, assigned_alternate_string3);
1248 EXPECT_EQ(alternate_string3, assigned_ptr_string3);
1249 EXPECT_EQ(embedded_nul_string7, assigned_embedded_nul_string7);
1253 ByteStringView null_string;
1254 ByteStringView lower_a_string(
"a");
1259 ByteStringView nul_string_from_char(nul);
1260 ByteStringView lower_a_string_from_char(lower_a);
1263 EXPECT_EQ(1u, nul_string_from_char.GetLength());
1264 EXPECT_NE(null_string, nul_string_from_char);
1266 EXPECT_EQ(1u, lower_a_string_from_char.GetLength());
1267 EXPECT_EQ(lower_a_string, lower_a_string_from_char);
1268 EXPECT_NE(nul_string_from_char, lower_a_string_from_char);
1270 ByteStringView longer_string(
"ab");
1271 EXPECT_NE(longer_string, lower_a_string_from_char);
1275 std::vector<uint8_t> null_vec;
1276 ByteStringView null_string(null_vec);
1277 EXPECT_EQ(0u, null_string.GetLength());
1279 std::vector<uint8_t> lower_a_vec(10,
static_cast<uint8_t>(
'a'));
1280 ByteStringView lower_a_string(lower_a_vec);
1281 EXPECT_EQ(
static_cast<size_t>(10), lower_a_string.GetLength());
1282 EXPECT_EQ(
"aaaaaaaaaa", lower_a_string);
1284 std::vector<uint8_t> cleared_vec;
1285 cleared_vec.push_back(42);
1286 cleared_vec.pop_back();
1287 ByteStringView cleared_string(cleared_vec);
1288 EXPECT_EQ(0u, cleared_string.GetLength());
1289 EXPECT_FALSE(cleared_string.raw_str());
1293 ByteStringView null_string;
1294 EXPECT_EQ(0u, null_string.GetID());
1296 ByteStringView empty_string(
"");
1297 EXPECT_EQ(0u, empty_string.GetID());
1299 ByteStringView short_string(
"ab");
1302 ByteStringView longer_string(
"abcdef");
1307 ByteStringView null_string;
1308 EXPECT_FALSE(null_string.Find(
'a').has_value());
1309 EXPECT_FALSE(null_string.Find(
'\0').has_value());
1311 ByteStringView empty_string(
"");
1312 EXPECT_FALSE(empty_string.Find(
'a').has_value());
1313 EXPECT_FALSE(empty_string.Find(
'\0').has_value());
1315 ByteStringView single_string(
"a");
1316 absl::optional<size_t> result = single_string.Find(
'a');
1317 ASSERT_TRUE(result.has_value());
1318 EXPECT_EQ(0u, result.value());
1319 EXPECT_FALSE(single_string.Find(
'b').has_value());
1320 EXPECT_FALSE(single_string.Find(
'\0').has_value());
1322 ByteStringView longer_string(
"abccc");
1323 result = longer_string.Find(
'a');
1324 ASSERT_TRUE(result.has_value());
1325 EXPECT_EQ(0u, result.value());
1326 result = longer_string.Find(
'c');
1327 ASSERT_TRUE(result.has_value());
1328 EXPECT_EQ(2u, result.value());
1329 EXPECT_FALSE(longer_string.Find(
'd').has_value());
1330 EXPECT_FALSE(longer_string.Find(
'\0').has_value());
1332 ByteStringView hibyte_string(
1335 result = hibyte_string.Find(
'\x8c');
1336 ASSERT_TRUE(result.has_value());
1337 EXPECT_EQ(2u, result.value());
1341 ByteStringView null_string;
1342 EXPECT_EQ(null_string, null_string.Substr(0));
1343 EXPECT_EQ(null_string, null_string.Substr(1));
1345 ByteStringView empty_string(
"");
1346 EXPECT_EQ(
"", empty_string.Substr(0));
1347 EXPECT_EQ(
"", empty_string.Substr(1));
1349 ByteStringView single_character(
"a");
1350 EXPECT_EQ(single_character, single_character.Substr(0));
1351 EXPECT_EQ(
"", single_character.Substr(1));
1353 ByteStringView longer_string(
"abcdef");
1354 EXPECT_EQ(longer_string, longer_string.Substr(0));
1355 EXPECT_EQ(
"", longer_string.Substr(187));
1357 ByteStringView trailing_substring(
"ef");
1358 EXPECT_EQ(trailing_substring, longer_string.Substr(4));
1362 ByteStringView null_string;
1363 EXPECT_EQ(null_string, null_string.Substr(0, 1));
1364 EXPECT_EQ(null_string, null_string.Substr(1, 1));
1366 ByteStringView empty_string(
"");
1367 EXPECT_EQ(
"", empty_string.Substr(0, 1));
1368 EXPECT_EQ(
"", empty_string.Substr(1, 1));
1370 ByteStringView single_character(
"a");
1371 EXPECT_EQ(
"", single_character.Substr(0, 0));
1372 EXPECT_EQ(single_character, single_character.Substr(0, 1));
1373 EXPECT_EQ(
"", single_character.Substr(1, 0));
1374 EXPECT_EQ(
"", single_character.Substr(1, 1));
1376 ByteStringView longer_string(
"abcdef");
1377 EXPECT_EQ(longer_string, longer_string.Substr(0, 6));
1378 EXPECT_EQ(
"", longer_string.Substr(0, 187));
1380 ByteStringView leading_substring(
"ab");
1381 EXPECT_EQ(leading_substring, longer_string.Substr(0, 2));
1383 ByteStringView middle_substring(
"bcde");
1384 EXPECT_EQ(middle_substring, longer_string.Substr(1, 4));
1386 ByteStringView trailing_substring(
"ef");
1387 EXPECT_EQ(trailing_substring, longer_string.Substr(4, 2));
1388 EXPECT_EQ(
"", longer_string.Substr(4, 3));
1411 ByteStringView empty;
1412 ByteStringView a(
"a");
1413 ByteStringView abc(
"abc");
1414 ByteStringView def(
"def");
1415 const char*
const c_null =
nullptr;
1416 const char*
const c_empty =
"";
1417 const char*
const c_a =
"a";
1418 const char*
const c_abc =
"abc";
1419 const char*
const c_def =
"def";
1421 EXPECT_FALSE(empty < empty);
1422 EXPECT_FALSE(a < a);
1423 EXPECT_FALSE(abc < abc);
1424 EXPECT_FALSE(def < def);
1425 EXPECT_FALSE(c_null < empty);
1426 EXPECT_FALSE(c_empty < empty);
1427 EXPECT_FALSE(c_a < a);
1428 EXPECT_FALSE(c_abc < abc);
1429 EXPECT_FALSE(c_def < def);
1430 EXPECT_FALSE(empty < c_null);
1431 EXPECT_FALSE(empty < c_empty);
1432 EXPECT_FALSE(a < c_a);
1433 EXPECT_FALSE(abc < c_abc);
1434 EXPECT_FALSE(def < c_def);
1436 EXPECT_TRUE(empty < a);
1437 EXPECT_FALSE(a < empty);
1438 EXPECT_TRUE(empty < c_a);
1439 EXPECT_FALSE(a < c_null);
1440 EXPECT_FALSE(a < c_empty);
1442 EXPECT_TRUE(empty < abc);
1443 EXPECT_FALSE(abc < empty);
1444 EXPECT_TRUE(empty < c_abc);
1445 EXPECT_FALSE(abc < c_null);
1446 EXPECT_FALSE(abc < c_empty);
1448 EXPECT_TRUE(empty < def);
1449 EXPECT_FALSE(def < empty);
1450 EXPECT_TRUE(empty < c_def);
1451 EXPECT_FALSE(def < c_null);
1452 EXPECT_FALSE(def < c_empty);
1454 EXPECT_TRUE(a < abc);
1455 EXPECT_FALSE(abc < a);
1456 EXPECT_TRUE(a < c_abc);
1457 EXPECT_FALSE(abc < c_a);
1459 EXPECT_TRUE(a < def);
1460 EXPECT_FALSE(def < a);
1461 EXPECT_TRUE(a < c_def);
1462 EXPECT_FALSE(def < c_a);
1464 EXPECT_TRUE(abc < def);
1465 EXPECT_FALSE(def < abc);
1466 EXPECT_TRUE(abc < c_def);
1467 EXPECT_FALSE(def < c_abc);
1471 ByteStringView byte_string_c(
"hello");
1472 EXPECT_TRUE(byte_string_c == byte_string_c);
1474 ByteStringView byte_string_c_same1(
"hello");
1475 EXPECT_TRUE(byte_string_c == byte_string_c_same1);
1476 EXPECT_TRUE(byte_string_c_same1 == byte_string_c);
1478 ByteStringView byte_string_c_same2(byte_string_c);
1479 EXPECT_TRUE(byte_string_c == byte_string_c_same2);
1480 EXPECT_TRUE(byte_string_c_same2 == byte_string_c);
1482 ByteStringView byte_string_c1(
"he");
1483 ByteStringView byte_string_c2(
"hellp");
1484 ByteStringView byte_string_c3(
"hellod");
1485 EXPECT_FALSE(byte_string_c == byte_string_c1);
1486 EXPECT_FALSE(byte_string_c == byte_string_c2);
1487 EXPECT_FALSE(byte_string_c == byte_string_c3);
1488 EXPECT_FALSE(byte_string_c1 == byte_string_c);
1489 EXPECT_FALSE(byte_string_c2 == byte_string_c);
1490 EXPECT_FALSE(byte_string_c3 == byte_string_c);
1493 EXPECT_TRUE(byte_string_c == byte_string_same1);
1494 EXPECT_TRUE(byte_string_same1 == byte_string_c);
1499 EXPECT_FALSE(byte_string_c == byte_string1);
1500 EXPECT_FALSE(byte_string_c == byte_string2);
1501 EXPECT_FALSE(byte_string_c == byte_string3);
1502 EXPECT_FALSE(byte_string1 == byte_string_c);
1503 EXPECT_FALSE(byte_string2 == byte_string_c);
1504 EXPECT_FALSE(byte_string3 == byte_string_c);
1506 const char*
const c_string_same1 =
"hello";
1507 EXPECT_TRUE(byte_string_c == c_string_same1);
1508 EXPECT_TRUE(c_string_same1 == byte_string_c);
1510 const char*
const c_string1 =
"he";
1511 const char*
const c_string2 =
"hellp";
1512 const char*
const c_string3 =
"hellod";
1513 EXPECT_FALSE(byte_string_c == c_string1);
1514 EXPECT_FALSE(byte_string_c == c_string2);
1515 EXPECT_FALSE(byte_string_c == c_string3);
1517 EXPECT_FALSE(c_string1 == byte_string_c);
1518 EXPECT_FALSE(c_string2 == byte_string_c);
1519 EXPECT_FALSE(c_string3 == byte_string_c);
1521 pdfium::span<
const uint8_t> span5(
1522 pdfium::as_bytes(pdfium::make_span(
"hello", 5u)));
1523 auto raw_span = byte_string_c.raw_span();
1525 std::equal(raw_span.begin(), raw_span.end(), span5.begin(), span5.end()));
1529 ByteStringView byte_string_c(
"hello");
1530 EXPECT_FALSE(byte_string_c != byte_string_c);
1532 ByteStringView byte_string_c_same1(
"hello");
1533 EXPECT_FALSE(byte_string_c != byte_string_c_same1);
1534 EXPECT_FALSE(byte_string_c_same1 != byte_string_c);
1536 ByteStringView byte_string_c_same2(byte_string_c);
1537 EXPECT_FALSE(byte_string_c != byte_string_c_same2);
1538 EXPECT_FALSE(byte_string_c_same2 != byte_string_c);
1540 ByteStringView byte_string_c1(
"he");
1541 ByteStringView byte_string_c2(
"hellp");
1542 ByteStringView byte_string_c3(
"hellod");
1543 EXPECT_TRUE(byte_string_c != byte_string_c1);
1544 EXPECT_TRUE(byte_string_c != byte_string_c2);
1545 EXPECT_TRUE(byte_string_c != byte_string_c3);
1546 EXPECT_TRUE(byte_string_c1 != byte_string_c);
1547 EXPECT_TRUE(byte_string_c2 != byte_string_c);
1548 EXPECT_TRUE(byte_string_c3 != byte_string_c);
1551 EXPECT_FALSE(byte_string_c != byte_string_same1);
1552 EXPECT_FALSE(byte_string_same1 != byte_string_c);
1557 EXPECT_TRUE(byte_string_c != byte_string1);
1558 EXPECT_TRUE(byte_string_c != byte_string2);
1559 EXPECT_TRUE(byte_string_c != byte_string3);
1560 EXPECT_TRUE(byte_string1 != byte_string_c);
1561 EXPECT_TRUE(byte_string2 != byte_string_c);
1562 EXPECT_TRUE(byte_string3 != byte_string_c);
1564 const char*
const c_string_same1 =
"hello";
1565 EXPECT_FALSE(byte_string_c != c_string_same1);
1566 EXPECT_FALSE(c_string_same1 != byte_string_c);
1568 const char*
const c_string1 =
"he";
1569 const char*
const c_string2 =
"hellp";
1570 const char*
const c_string3 =
"hellod";
1571 EXPECT_TRUE(byte_string_c != c_string1);
1572 EXPECT_TRUE(byte_string_c != c_string2);
1573 EXPECT_TRUE(byte_string_c != c_string3);
1575 EXPECT_TRUE(c_string1 != byte_string_c);
1576 EXPECT_TRUE(c_string2 != byte_string_c);
1577 EXPECT_TRUE(c_string3 != byte_string_c);
1651 ByteStringView multi_str(
"abcd");
1652 auto iter = multi_str.rbegin();
1653 EXPECT_FALSE(iter == multi_str.rend());
1657 EXPECT_EQ(
'c', *iter);
1658 EXPECT_FALSE(iter == multi_str.rend());
1662 EXPECT_EQ(
'b', *iter);
1663 EXPECT_FALSE(iter == multi_str.rend());
1667 EXPECT_EQ(
'a', *iter);
1668 EXPECT_FALSE(iter == multi_str.rend());
1672 EXPECT_TRUE(iter == multi_str.rend());
1676 EXPECT_EQ(
'a', *iter);
1677 EXPECT_FALSE(iter == multi_str.rend());
1681 EXPECT_EQ(
'b', *iter);
1682 EXPECT_FALSE(iter == multi_str.rend());
1686 EXPECT_EQ(
'c', *iter);
1687 EXPECT_FALSE(iter == multi_str.rend());
1691 EXPECT_EQ(
'd', *iter);
1692 EXPECT_TRUE(iter == multi_str.rbegin());
1696 ByteStringView str(
"aaaaaaaaaaaaaaaaab");
1697 EXPECT_FALSE(
std::all_of(str.begin(), str.end(),
1698 [](
const char& c) {
return c ==
'a'; }));
1700 EXPECT_FALSE(
std::none_of(str.begin(), str.end(),
1701 [](
const char& c) {
return c ==
'a'; }));
1703 EXPECT_TRUE(
std::any_of(str.begin(), str.end(),
1704 [](
const char& c) {
return c ==
'a'; }));
1706 EXPECT_TRUE(pdfium::Contains(str,
'a'));
1707 EXPECT_TRUE(pdfium::Contains(str,
'b'));
1708 EXPECT_FALSE(pdfium::Contains(str,
'z'));
1730 EXPECT_EQ(0u, empty_str.GetLength());
1732 const char* cstr = empty_str
.c_str();
1734 EXPECT_EQ(0u, strlen(cstr));
1739 pdfium::span<
const char> cspan = empty_str.span();
1740 EXPECT_TRUE(cspan.empty());
1741 EXPECT_FALSE(cspan.data());
1743 pdfium::span<
const uint8_t> rspan = empty_str.raw_span();
1744 EXPECT_TRUE(rspan.empty());
1745 EXPECT_FALSE(rspan.data());
1893 std::ostringstream stream;
1896 EXPECT_EQ(
"", stream.str());
1901 std::ostringstream stream;
1902 ByteStringView str(
"def");
1903 stream <<
"abc" << str <<
"ghi";
1904 EXPECT_EQ(
"abcdefghi", stream.str());
1909 std::ostringstream stream;
1910 ByteStringView str(
"abc");
1913 EXPECT_EQ(
"abc", stream.str());
1918 std::ostringstream stream;
1919 ByteStringView str(
"abc");
1924 EXPECT_EQ(
"123", stream.str());
1930 std::ostringstream stream;
1931 char stringWithNulls[]{
'x',
'y',
'\0',
'z'};
1932 ByteStringView str(stringWithNulls);
1933 EXPECT_EQ(2u, str.GetLength());
1935 EXPECT_EQ(2u, stream.tellp());
1942 std::ostringstream stream;
1943 char stringWithNulls[]{
'x',
'y',
'\0',
'z'};
1944 ByteStringView str(stringWithNulls, 4);
1945 EXPECT_EQ(4u, str.GetLength());
1947 EXPECT_EQ(4u, stream.tellp());
1953 std::ostringstream stream;
1954 ByteStringView str1(
"abc");
1955 ByteStringView str2(
"def");
1956 stream << str1 << str2;
1957 EXPECT_EQ(
"abcdef", stream.str());
1977 EXPECT_EQ(0u, FX_HashCode_GetA(
""));
1978 EXPECT_EQ(65u, FX_HashCode_GetA(
"A"));
1979 EXPECT_EQ(97u, FX_HashCode_GetLoweredA(
"A"));
1980 EXPECT_EQ(31 * 65u + 66u, FX_HashCode_GetA(
"AB"));
1981 EXPECT_EQ(31u * 65u + 255u, FX_HashCode_GetA(
"A\xff"));
1982 EXPECT_EQ(31u * 97u + 255u, FX_HashCode_GetLoweredA(
"A\xff"));
1986 EXPECT_EQ(0u, FX_HashCode_GetAsIfW(
""));
1987 EXPECT_EQ(65u, FX_HashCode_GetAsIfW(
"A"));
1988 EXPECT_EQ(97u, FX_HashCode_GetLoweredAsIfW(
"A"));
1989 EXPECT_EQ(1313u * 65u + 66u, FX_HashCode_GetAsIfW(
"AB"));
1990 EXPECT_EQ(1313u * 65u + 255u, FX_HashCode_GetAsIfW(
"A\xff"));
1991 EXPECT_EQ(1313u * 97u + 255u, FX_HashCode_GetLoweredAsIfW(
"A\xff"));