Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
bytestring_unittest.cpp
Go to the documentation of this file.
1// Copyright 2014 The PDFium Authors
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "core/fxcrt/bytestring.h"
6
7#include <limits.h>
8
9#include <algorithm>
10#include <functional>
11#include <iterator>
12#include <set>
13#include <vector>
14
15#include "core/fxcrt/compiler_specific.h"
16#include "core/fxcrt/containers/contains.h"
17#include "core/fxcrt/fx_string.h"
18#include "core/fxcrt/span.h"
19#include "testing/gtest/include/gtest/gtest.h"
20
21namespace fxcrt {
22
23TEST(ByteString, ElementAccess) {
24 const ByteString empty;
25 pdfium::span<const char> empty_span = empty.span();
26 pdfium::span<const char> empty_span_with_terminator =
27 empty.span_with_terminator();
28 EXPECT_EQ(0u, empty_span.size());
29 ASSERT_EQ(1u, empty_span_with_terminator.size());
30 EXPECT_EQ('\0', empty_span_with_terminator[0]);
31
32 const ByteString abc("abc");
33 EXPECT_EQ('a', abc[0]);
34 EXPECT_EQ('b', abc[1]);
35 EXPECT_EQ('c', abc[2]);
36#ifndef NDEBUG
37 EXPECT_DEATH({ abc[3]; }, "");
38#endif
39
40 pdfium::span<const char> abc_span = abc.span();
41 EXPECT_EQ(3u, abc_span.size());
42 EXPECT_EQ(0, memcmp(abc_span.data(), "abc", 3));
43
44 pdfium::span<const char> abc_span_with_terminator =
45 abc.span_with_terminator();
46 EXPECT_EQ(4u, abc_span_with_terminator.size());
47 EXPECT_EQ(0, memcmp(abc_span_with_terminator.data(), "abc", 4));
48
49 pdfium::span<const uint8_t> abc_raw_span = abc.unsigned_span();
50 EXPECT_EQ(3u, abc_raw_span.size());
51 EXPECT_EQ(0, memcmp(abc_raw_span.data(), "abc", 3));
52
53 pdfium::span<const uint8_t> abc_raw_span_with_terminator =
54 abc.unsigned_span_with_terminator();
55 EXPECT_EQ(4u, abc_raw_span_with_terminator.size());
56 EXPECT_EQ(0, memcmp(abc_raw_span_with_terminator.data(), "abc", 4));
57
58 ByteString mutable_abc = abc;
59 EXPECT_EQ(abc.c_str(), mutable_abc.c_str());
60 EXPECT_EQ('a', mutable_abc[0]);
61 EXPECT_EQ('b', mutable_abc[1]);
62 EXPECT_EQ('c', mutable_abc[2]);
63 EXPECT_EQ(abc.c_str(), mutable_abc.c_str());
64 EXPECT_EQ("abc", abc);
65
66 const char* c_str = abc.c_str();
67 mutable_abc.SetAt(0, 'd');
68 EXPECT_EQ(c_str, abc.c_str());
69 EXPECT_NE(c_str, mutable_abc.c_str());
70 EXPECT_EQ("abc", abc);
71 EXPECT_EQ("dbc", mutable_abc);
72
73 mutable_abc.SetAt(1, 'e');
74 EXPECT_EQ("abc", abc);
75 EXPECT_EQ("dec", mutable_abc);
76
77 mutable_abc.SetAt(2, 'f');
78 EXPECT_EQ("abc", abc);
79 EXPECT_EQ("def", mutable_abc);
80#ifndef NDEBUG
81 EXPECT_DEATH({ mutable_abc.SetAt(3, 'g'); }, "");
82 EXPECT_EQ("abc", abc);
83#endif
84}
85
86TEST(ByteString, Construct) {
87 {
88 // Copy-construct.
89 ByteString string1("abc");
90 ByteString string2(string1);
91 EXPECT_EQ("abc", string1);
92 EXPECT_EQ("abc", string2);
93 EXPECT_EQ(2, string1.ReferenceCountForTesting());
94 EXPECT_EQ(2, string2.ReferenceCountForTesting());
95 }
96 {
97 // Move-construct.
98 ByteString string1("abc");
99 ByteString string2(std::move(string1));
100 EXPECT_TRUE(string1.IsEmpty());
101 EXPECT_EQ("abc", string2);
102 EXPECT_EQ(0, string1.ReferenceCountForTesting());
103 EXPECT_EQ(1, string2.ReferenceCountForTesting());
104 }
105}
106
107TEST(ByteString, Assign) {
108 {
109 // Copy-assign.
110 ByteString string1;
111 EXPECT_EQ(0, string1.ReferenceCountForTesting());
112 {
113 ByteString string2("abc");
114 EXPECT_EQ(1, string2.ReferenceCountForTesting());
115
116 string1 = string2;
117 EXPECT_EQ(2, string1.ReferenceCountForTesting());
118 EXPECT_EQ(2, string2.ReferenceCountForTesting());
119 }
120 EXPECT_EQ(1, string1.ReferenceCountForTesting());
121 }
122 {
123 // Move-assign.
124 ByteString string1;
125 EXPECT_EQ(0, string1.ReferenceCountForTesting());
126 {
127 ByteString string2("abc");
128 EXPECT_EQ(1, string2.ReferenceCountForTesting());
129
130 string1 = std::move(string2);
131 EXPECT_EQ("abc", string1);
132 EXPECT_TRUE(string2.IsEmpty());
133 EXPECT_EQ(1, string1.ReferenceCountForTesting());
134 EXPECT_EQ(0, string2.ReferenceCountForTesting());
135 }
136 EXPECT_EQ(1, string1.ReferenceCountForTesting());
137 }
138 {
139 // From char*.
140 ByteString string1 = "abc";
141 EXPECT_EQ("abc", string1);
142 string1 = nullptr;
143 EXPECT_TRUE(string1.IsEmpty());
144 string1 = "def";
145 EXPECT_EQ("def", string1);
146 string1 = "";
147 EXPECT_TRUE(string1.IsEmpty());
148 }
149 {
150 // From ByteStringView.
151 ByteString string1(ByteStringView("abc"));
152 EXPECT_EQ("abc", string1);
153 string1 = ByteStringView("");
154 EXPECT_TRUE(string1.IsEmpty());
155 string1 = ByteStringView("def");
156 EXPECT_EQ("def", string1);
157 }
158}
159
160TEST(ByteString, OperatorLT) {
161 ByteString empty;
162 ByteString a("a");
163 ByteString abc("abc");
164 ByteString def("def");
165 ByteStringView v_empty;
166 ByteStringView v_a("a");
167 ByteStringView v_abc("abc");
168 ByteStringView v_def("def");
169 const char* const c_null = nullptr;
170 const char* const c_empty = "";
171 const char* const c_a = "a";
172 const char* const c_abc = "abc";
173 const char* const c_def = "def";
174
175 EXPECT_FALSE(empty < empty);
176 EXPECT_FALSE(a < a);
177 EXPECT_FALSE(abc < abc);
178 EXPECT_FALSE(def < def);
179 EXPECT_FALSE(c_null < empty);
180 EXPECT_FALSE(c_empty < empty);
181 EXPECT_FALSE(c_a < a);
182 EXPECT_FALSE(c_abc < abc);
183 EXPECT_FALSE(c_def < def);
184 EXPECT_FALSE(empty < c_null);
185 EXPECT_FALSE(empty < c_empty);
186 EXPECT_FALSE(a < c_a);
187 EXPECT_FALSE(abc < c_abc);
188 EXPECT_FALSE(def < c_def);
189 EXPECT_FALSE(empty < v_empty);
190 EXPECT_FALSE(a < v_a);
191 EXPECT_FALSE(abc < v_abc);
192 EXPECT_FALSE(def < v_def);
193
194 EXPECT_TRUE(empty < a);
195 EXPECT_FALSE(a < empty);
196 EXPECT_TRUE(c_null < a);
197 EXPECT_TRUE(c_empty < a);
198 EXPECT_FALSE(c_a < empty);
199 EXPECT_TRUE(empty < c_a);
200 EXPECT_FALSE(a < c_null);
201 EXPECT_FALSE(a < c_empty);
202 EXPECT_TRUE(empty < v_a);
203 EXPECT_FALSE(a < v_empty);
204
205 EXPECT_TRUE(empty < abc);
206 EXPECT_FALSE(abc < empty);
207 EXPECT_TRUE(c_null < abc);
208 EXPECT_TRUE(c_empty < abc);
209 EXPECT_FALSE(c_abc < empty);
210 EXPECT_TRUE(empty < c_abc);
211 EXPECT_FALSE(abc < c_null);
212 EXPECT_FALSE(abc < c_empty);
213 EXPECT_TRUE(empty < v_abc);
214 EXPECT_FALSE(abc < v_empty);
215
216 EXPECT_TRUE(empty < def);
217 EXPECT_FALSE(def < empty);
218 EXPECT_TRUE(c_null < def);
219 EXPECT_TRUE(c_empty < def);
220 EXPECT_FALSE(c_def < empty);
221 EXPECT_TRUE(empty < c_def);
222 EXPECT_FALSE(def < c_null);
223 EXPECT_FALSE(def < c_empty);
224 EXPECT_TRUE(empty < v_def);
225 EXPECT_FALSE(def < v_empty);
226
227 EXPECT_TRUE(a < abc);
228 EXPECT_FALSE(abc < a);
229 EXPECT_TRUE(c_a < abc);
230 EXPECT_FALSE(c_abc < a);
231 EXPECT_TRUE(a < c_abc);
232 EXPECT_FALSE(abc < c_a);
233 EXPECT_TRUE(a < v_abc);
234 EXPECT_FALSE(abc < v_a);
235
236 EXPECT_TRUE(a < def);
237 EXPECT_FALSE(def < a);
238 EXPECT_TRUE(c_a < def);
239 EXPECT_FALSE(c_def < a);
240 EXPECT_TRUE(a < c_def);
241 EXPECT_FALSE(def < c_a);
242 EXPECT_TRUE(a < v_def);
243 EXPECT_FALSE(def < v_a);
244
245 EXPECT_TRUE(abc < def);
246 EXPECT_FALSE(def < abc);
247 EXPECT_TRUE(c_abc < def);
248 EXPECT_FALSE(c_def < abc);
249 EXPECT_TRUE(abc < c_def);
250 EXPECT_FALSE(def < c_abc);
251 EXPECT_TRUE(abc < v_def);
252 EXPECT_FALSE(def < v_abc);
253
254 EXPECT_TRUE(v_empty < a);
255 EXPECT_TRUE(v_empty < c_a);
256
257 std::set<ByteString, std::less<>> str_set;
258 bool inserted = str_set.insert(ByteString("hello")).second;
259 ASSERT_TRUE(inserted);
260 EXPECT_TRUE(pdfium::Contains(str_set, ByteString("hello")));
261 EXPECT_TRUE(pdfium::Contains(str_set, ByteStringView("hello")));
262 EXPECT_TRUE(pdfium::Contains(str_set, "hello"));
263 EXPECT_FALSE(pdfium::Contains(str_set, ByteString("goodbye")));
264 EXPECT_FALSE(pdfium::Contains(str_set, ByteStringView("goodbye")));
265 EXPECT_FALSE(pdfium::Contains(str_set, "goodbye"));
266}
267
268TEST(ByteString, OperatorEQ) {
269 ByteString null_string;
270 EXPECT_TRUE(null_string == null_string);
271
272 ByteString empty_string("");
273 EXPECT_TRUE(empty_string == empty_string);
274 EXPECT_TRUE(empty_string == null_string);
275 EXPECT_TRUE(null_string == empty_string);
276
277 ByteString deleted_string("hello");
278 deleted_string.Delete(0, 5);
279 EXPECT_TRUE(deleted_string == deleted_string);
280 EXPECT_TRUE(deleted_string == null_string);
281 EXPECT_TRUE(deleted_string == empty_string);
282 EXPECT_TRUE(null_string == deleted_string);
283 EXPECT_TRUE(empty_string == deleted_string);
284
285 ByteString byte_string("hello");
286 EXPECT_TRUE(byte_string == byte_string);
287 EXPECT_FALSE(byte_string == null_string);
288 EXPECT_FALSE(byte_string == empty_string);
289 EXPECT_FALSE(byte_string == deleted_string);
290 EXPECT_FALSE(null_string == byte_string);
291 EXPECT_FALSE(empty_string == byte_string);
292 EXPECT_FALSE(deleted_string == byte_string);
293
294 ByteString byte_string_same1("hello");
295 EXPECT_TRUE(byte_string == byte_string_same1);
296 EXPECT_TRUE(byte_string_same1 == byte_string);
297
298 ByteString byte_string_same2(byte_string);
299 EXPECT_TRUE(byte_string == byte_string_same2);
300 EXPECT_TRUE(byte_string_same2 == byte_string);
301
302 ByteString byte_string1("he");
303 ByteString byte_string2("hellp");
304 ByteString byte_string3("hellod");
305 EXPECT_FALSE(byte_string == byte_string1);
306 EXPECT_FALSE(byte_string == byte_string2);
307 EXPECT_FALSE(byte_string == byte_string3);
308 EXPECT_FALSE(byte_string1 == byte_string);
309 EXPECT_FALSE(byte_string2 == byte_string);
310 EXPECT_FALSE(byte_string3 == byte_string);
311
312 ByteStringView null_string_c;
313 ByteStringView empty_string_c("");
314 EXPECT_TRUE(null_string == null_string_c);
315 EXPECT_TRUE(null_string == empty_string_c);
316 EXPECT_TRUE(empty_string == null_string_c);
317 EXPECT_TRUE(empty_string == empty_string_c);
318 EXPECT_TRUE(deleted_string == null_string_c);
319 EXPECT_TRUE(deleted_string == empty_string_c);
320 EXPECT_TRUE(null_string_c == null_string);
321 EXPECT_TRUE(empty_string_c == null_string);
322 EXPECT_TRUE(null_string_c == empty_string);
323 EXPECT_TRUE(empty_string_c == empty_string);
324 EXPECT_TRUE(null_string_c == deleted_string);
325 EXPECT_TRUE(empty_string_c == deleted_string);
326
327 ByteStringView byte_string_c_same1("hello");
328 EXPECT_TRUE(byte_string == byte_string_c_same1);
329 EXPECT_TRUE(byte_string_c_same1 == byte_string);
330
331 ByteStringView byte_string_c1("he");
332 ByteStringView byte_string_c2("hellp");
333 ByteStringView byte_string_c3("hellod");
334 EXPECT_FALSE(byte_string == byte_string_c1);
335 EXPECT_FALSE(byte_string == byte_string_c2);
336 EXPECT_FALSE(byte_string == byte_string_c3);
337 EXPECT_FALSE(byte_string_c1 == byte_string);
338 EXPECT_FALSE(byte_string_c2 == byte_string);
339 EXPECT_FALSE(byte_string_c3 == byte_string);
340
341 const char* const c_null_string = nullptr;
342 const char* const c_empty_string = "";
343 EXPECT_TRUE(null_string == c_null_string);
344 EXPECT_TRUE(null_string == c_empty_string);
345 EXPECT_TRUE(empty_string == c_null_string);
346 EXPECT_TRUE(empty_string == c_empty_string);
347 EXPECT_TRUE(deleted_string == c_null_string);
348 EXPECT_TRUE(deleted_string == c_empty_string);
349 EXPECT_TRUE(c_null_string == null_string);
350 EXPECT_TRUE(c_empty_string == null_string);
351 EXPECT_TRUE(c_null_string == empty_string);
352 EXPECT_TRUE(c_empty_string == empty_string);
353 EXPECT_TRUE(c_null_string == deleted_string);
354 EXPECT_TRUE(c_empty_string == deleted_string);
355
356 const char* const c_string_same1 = "hello";
357 EXPECT_TRUE(byte_string == c_string_same1);
358 EXPECT_TRUE(c_string_same1 == byte_string);
359
360 const char* const c_string1 = "he";
361 const char* const c_string2 = "hellp";
362 const char* const c_string3 = "hellod";
363 EXPECT_FALSE(byte_string == c_string1);
364 EXPECT_FALSE(byte_string == c_string2);
365 EXPECT_FALSE(byte_string == c_string3);
366 EXPECT_FALSE(c_string1 == byte_string);
367 EXPECT_FALSE(c_string2 == byte_string);
368 EXPECT_FALSE(c_string3 == byte_string);
369}
370
371TEST(ByteString, OperatorNE) {
372 ByteString null_string;
373 EXPECT_FALSE(null_string != null_string);
374
375 ByteString empty_string("");
376 EXPECT_FALSE(empty_string != empty_string);
377 EXPECT_FALSE(empty_string != null_string);
378 EXPECT_FALSE(null_string != empty_string);
379
380 ByteString deleted_string("hello");
381 deleted_string.Delete(0, 5);
382 EXPECT_FALSE(deleted_string != deleted_string);
383 EXPECT_FALSE(deleted_string != null_string);
384 EXPECT_FALSE(deleted_string != empty_string);
385 EXPECT_FALSE(deleted_string != deleted_string);
386 EXPECT_FALSE(null_string != deleted_string);
387 EXPECT_FALSE(empty_string != deleted_string);
388 EXPECT_FALSE(deleted_string != deleted_string);
389
390 ByteString byte_string("hello");
391 EXPECT_FALSE(byte_string != byte_string);
392 EXPECT_TRUE(byte_string != null_string);
393 EXPECT_TRUE(byte_string != empty_string);
394 EXPECT_TRUE(byte_string != deleted_string);
395 EXPECT_TRUE(null_string != byte_string);
396 EXPECT_TRUE(empty_string != byte_string);
397 EXPECT_TRUE(deleted_string != byte_string);
398
399 ByteString byte_string_same1("hello");
400 EXPECT_FALSE(byte_string != byte_string_same1);
401 EXPECT_FALSE(byte_string_same1 != byte_string);
402
403 ByteString byte_string_same2(byte_string);
404 EXPECT_FALSE(byte_string != byte_string_same2);
405 EXPECT_FALSE(byte_string_same2 != byte_string);
406
407 ByteString byte_string1("he");
408 ByteString byte_string2("hellp");
409 ByteString byte_string3("hellod");
410 EXPECT_TRUE(byte_string != byte_string1);
411 EXPECT_TRUE(byte_string != byte_string2);
412 EXPECT_TRUE(byte_string != byte_string3);
413 EXPECT_TRUE(byte_string1 != byte_string);
414 EXPECT_TRUE(byte_string2 != byte_string);
415 EXPECT_TRUE(byte_string3 != byte_string);
416
417 ByteStringView null_string_c;
418 ByteStringView empty_string_c("");
419 EXPECT_FALSE(null_string != null_string_c);
420 EXPECT_FALSE(null_string != empty_string_c);
421 EXPECT_FALSE(empty_string != null_string_c);
422 EXPECT_FALSE(empty_string != empty_string_c);
423 EXPECT_FALSE(null_string_c != null_string);
424 EXPECT_FALSE(empty_string_c != null_string);
425 EXPECT_FALSE(null_string_c != empty_string);
426 EXPECT_FALSE(empty_string_c != empty_string);
427
428 ByteStringView byte_string_c_same1("hello");
429 EXPECT_FALSE(byte_string != byte_string_c_same1);
430 EXPECT_FALSE(byte_string_c_same1 != byte_string);
431
432 ByteStringView byte_string_c1("he");
433 ByteStringView byte_string_c2("hellp");
434 ByteStringView byte_string_c3("hellod");
435 EXPECT_TRUE(byte_string != byte_string_c1);
436 EXPECT_TRUE(byte_string != byte_string_c2);
437 EXPECT_TRUE(byte_string != byte_string_c3);
438 EXPECT_TRUE(byte_string_c1 != byte_string);
439 EXPECT_TRUE(byte_string_c2 != byte_string);
440 EXPECT_TRUE(byte_string_c3 != byte_string);
441
442 const char* const c_null_string = nullptr;
443 const char* const c_empty_string = "";
444 EXPECT_FALSE(null_string != c_null_string);
445 EXPECT_FALSE(null_string != c_empty_string);
446 EXPECT_FALSE(empty_string != c_null_string);
447 EXPECT_FALSE(empty_string != c_empty_string);
448 EXPECT_FALSE(deleted_string != c_null_string);
449 EXPECT_FALSE(deleted_string != c_empty_string);
450 EXPECT_FALSE(c_null_string != null_string);
451 EXPECT_FALSE(c_empty_string != null_string);
452 EXPECT_FALSE(c_null_string != empty_string);
453 EXPECT_FALSE(c_empty_string != empty_string);
454 EXPECT_FALSE(c_null_string != deleted_string);
455 EXPECT_FALSE(c_empty_string != deleted_string);
456
457 const char* const c_string_same1 = "hello";
458 EXPECT_FALSE(byte_string != c_string_same1);
459 EXPECT_FALSE(c_string_same1 != byte_string);
460
461 const char* const c_string1 = "he";
462 const char* const c_string2 = "hellp";
463 const char* const c_string3 = "hellod";
464 EXPECT_TRUE(byte_string != c_string1);
465 EXPECT_TRUE(byte_string != c_string2);
466 EXPECT_TRUE(byte_string != c_string3);
467 EXPECT_TRUE(c_string1 != byte_string);
468 EXPECT_TRUE(c_string2 != byte_string);
469 EXPECT_TRUE(c_string3 != byte_string);
470}
471
472TEST(ByteString, OperatorPlus) {
473 EXPECT_EQ("I like dogs", "I like " + ByteString("dogs"));
474 EXPECT_EQ("Dogs like me", ByteString("Dogs") + " like me");
475 EXPECT_EQ("Oh no, error number 42",
476 "Oh no, error number " + ByteString::Format("%d", 42));
477
478 {
479 // Make sure operator+= and Concat() increases string memory allocation
480 // geometrically.
481 int allocations = 0;
482 ByteString str("ABCDEFGHIJKLMN");
483 const char* buffer = str.c_str();
484 for (size_t i = 0; i < 10000; ++i) {
485 str += "!";
486 const char* new_buffer = str.c_str();
487 if (new_buffer != buffer) {
488 buffer = new_buffer;
489 ++allocations;
490 }
491 }
492 EXPECT_LT(allocations, 25);
493 EXPECT_GT(allocations, 10);
494 }
495}
496
497TEST(ByteString, Concat) {
498 ByteString fred;
499 fred.Concat("FRED", 4);
500 EXPECT_EQ("FRED", fred);
501
502 fred.Concat("DY", 2);
503 EXPECT_EQ("FREDDY", fred);
504
505 fred.Delete(3, 3);
506 EXPECT_EQ("FRE", fred);
507
508 fred.Concat("D", 1);
509 EXPECT_EQ("FRED", fred);
510
511 ByteString copy = fred;
512 fred.Concat("DY", 2);
513 EXPECT_EQ("FREDDY", fred);
514 EXPECT_EQ("FRED", copy);
515}
516
517TEST(ByteString, Remove) {
518 ByteString freed("FREED");
519 freed.Remove('E');
520 EXPECT_EQ("FRD", freed);
521 freed.Remove('F');
522 EXPECT_EQ("RD", freed);
523 freed.Remove('D');
524 EXPECT_EQ("R", freed);
525 freed.Remove('X');
526 EXPECT_EQ("R", freed);
527 freed.Remove('R');
528 EXPECT_EQ("", freed);
529
530 ByteString empty;
531 empty.Remove('X');
532 EXPECT_EQ("", empty);
533}
534
535TEST(ByteString, RemoveCopies) {
536 ByteString freed("FREED");
537 const char* old_buffer = freed.c_str();
538
539 // No change with single reference - no copy.
540 freed.Remove('Q');
541 EXPECT_EQ("FREED", freed);
542 EXPECT_EQ(old_buffer, freed.c_str());
543
544 // Change with single reference - no copy.
545 freed.Remove('E');
546 EXPECT_EQ("FRD", freed);
547 EXPECT_EQ(old_buffer, freed.c_str());
548
549 // No change with multiple references - no copy.
550 ByteString shared(freed);
551 freed.Remove('Q');
552 EXPECT_EQ("FRD", freed);
553 EXPECT_EQ(old_buffer, freed.c_str());
554 EXPECT_EQ(old_buffer, shared.c_str());
555
556 // Change with multiple references -- must copy.
557 freed.Remove('D');
558 EXPECT_EQ("FR", freed);
559 EXPECT_NE(old_buffer, freed.c_str());
560 EXPECT_EQ("FRD", shared);
561 EXPECT_EQ(old_buffer, shared.c_str());
562}
563
564TEST(ByteString, Replace) {
565 ByteString empty;
566 empty.Replace("", "CLAMS");
567 empty.Replace("xx", "CLAMS");
568 EXPECT_EQ("", empty);
569
570 ByteString fred("FRED");
571 fred.Replace("", "");
572 EXPECT_EQ("FRED", fred);
573 fred.Replace("", "CLAMS");
574 EXPECT_EQ("FRED", fred);
575 fred.Replace("FR", "BL");
576 EXPECT_EQ("BLED", fred);
577 fred.Replace("D", "DDY");
578 EXPECT_EQ("BLEDDY", fred);
579 fred.Replace("LEDD", "");
580 EXPECT_EQ("BY", fred);
581 fred.Replace("X", "CLAMS");
582 EXPECT_EQ("BY", fred);
583 fred.Replace("BY", "HI");
584 EXPECT_EQ("HI", fred);
585 fred.Replace("I", "IHIHI");
586 EXPECT_EQ("HIHIHI", fred);
587 fred.Replace("HI", "HO");
588 EXPECT_EQ("HOHOHO", fred);
589 fred.Replace("HO", "");
590 EXPECT_EQ("", fred);
591
592 ByteString five_xs("xxxxx");
593 five_xs.Replace("xx", "xxx");
594 EXPECT_EQ("xxxxxxx", five_xs);
595
596 ByteString five_ys("yyyyy");
597 five_ys.Replace("yy", "y");
598 EXPECT_EQ("yyy", five_ys);
599}
600
601TEST(ByteString, Insert) {
602 ByteString fred("FRED");
603 EXPECT_EQ(5u, fred.Insert(0, 'S'));
604 EXPECT_EQ("SFRED", fred);
605 EXPECT_EQ(6u, fred.Insert(1, 'T'));
606 EXPECT_EQ("STFRED", fred);
607 EXPECT_EQ(7u, fred.Insert(4, 'U'));
608 EXPECT_EQ("STFRUED", fred);
609 EXPECT_EQ(8u, fred.Insert(7, 'V'));
610 EXPECT_EQ("STFRUEDV", fred);
611 EXPECT_EQ(8u, fred.Insert(12, 'P'));
612 EXPECT_EQ("STFRUEDV", fred);
613 {
614 ByteString empty;
615 EXPECT_EQ(1u, empty.Insert(0, 'X'));
616 EXPECT_EQ("X", empty);
617 }
618 {
619 ByteString empty;
620 EXPECT_EQ(0u, empty.Insert(5, 'X'));
621 EXPECT_NE("X", empty);
622 }
623}
624
625TEST(ByteString, InsertAtFrontAndInsertAtBack) {
626 {
627 ByteString empty;
628 EXPECT_EQ(1u, empty.InsertAtFront('D'));
629 EXPECT_EQ("D", empty);
630 EXPECT_EQ(2u, empty.InsertAtFront('E'));
631 EXPECT_EQ("ED", empty);
632 EXPECT_EQ(3u, empty.InsertAtFront('R'));
633 EXPECT_EQ("RED", empty);
634 EXPECT_EQ(4u, empty.InsertAtFront('F'));
635 EXPECT_EQ("FRED", empty);
636 }
637 {
638 ByteString empty;
639 EXPECT_EQ(1u, empty.InsertAtBack('F'));
640 EXPECT_EQ("F", empty);
641 EXPECT_EQ(2u, empty.InsertAtBack('R'));
642 EXPECT_EQ("FR", empty);
643 EXPECT_EQ(3u, empty.InsertAtBack('E'));
644 EXPECT_EQ("FRE", empty);
645 EXPECT_EQ(4u, empty.InsertAtBack('D'));
646 EXPECT_EQ("FRED", empty);
647 }
648 {
649 ByteString empty;
650 EXPECT_EQ(1u, empty.InsertAtBack('E'));
651 EXPECT_EQ("E", empty);
652 EXPECT_EQ(2u, empty.InsertAtFront('R'));
653 EXPECT_EQ("RE", empty);
654 EXPECT_EQ(3u, empty.InsertAtBack('D'));
655 EXPECT_EQ("RED", empty);
656 EXPECT_EQ(4u, empty.InsertAtFront('F'));
657 EXPECT_EQ("FRED", empty);
658 }
659}
660
661TEST(ByteString, Delete) {
662 ByteString fred("FRED");
663 EXPECT_EQ(4u, fred.Delete(0, 0));
664 EXPECT_EQ("FRED", fred);
665 EXPECT_EQ(2u, fred.Delete(0, 2));
666 EXPECT_EQ("ED", fred);
667 EXPECT_EQ(1u, fred.Delete(1));
668 EXPECT_EQ("E", fred);
669 EXPECT_EQ(0u, fred.Delete(0));
670 EXPECT_EQ("", fred);
671 EXPECT_EQ(0u, fred.Delete(0));
672 EXPECT_EQ("", fred);
673
674 ByteString empty;
675 EXPECT_EQ(0u, empty.Delete(0));
676 EXPECT_EQ("", empty);
677 EXPECT_EQ(0u, empty.Delete(1));
678 EXPECT_EQ("", empty);
679}
680
681TEST(ByteString, OneArgSubstr) {
682 ByteString fred("FRED");
683 EXPECT_EQ("FRED", fred.Substr(0));
684 EXPECT_EQ("RED", fred.Substr(1));
685 EXPECT_EQ("ED", fred.Substr(2));
686 EXPECT_EQ("D", fred.Substr(3));
687 EXPECT_EQ("", fred.Substr(4));
688
689 ByteString empty;
690 EXPECT_EQ("", empty.Substr(0));
691 EXPECT_EQ("", empty.Substr(1));
692}
693
694TEST(ByteString, TwoArgSubstr) {
695 ByteString fred("FRED");
696 EXPECT_EQ("", fred.Substr(0, 0));
697 EXPECT_EQ("", fred.Substr(3, 0));
698 EXPECT_EQ("FRED", fred.Substr(0, 4));
699 EXPECT_EQ("RED", fred.Substr(1, 3));
700 EXPECT_EQ("ED", fred.Substr(2, 2));
701 EXPECT_EQ("D", fred.Substr(3, 1));
702 EXPECT_EQ("F", fred.Substr(0, 1));
703 EXPECT_EQ("R", fred.Substr(1, 1));
704 EXPECT_EQ("E", fred.Substr(2, 1));
705 EXPECT_EQ("D", fred.Substr(3, 1));
706 EXPECT_EQ("FR", fred.Substr(0, 2));
707 EXPECT_EQ("FRED", fred.Substr(0, 4));
708 EXPECT_EQ("", fred.Substr(0, 10));
709
710 EXPECT_EQ("RED", fred.Substr(1, 3));
711 EXPECT_EQ("", fred.Substr(4, 1));
712
713 ByteString empty;
714 EXPECT_EQ("", empty.Substr(0, 0));
715}
716
717TEST(ByteString, First) {
718 ByteString fred("FRED");
719 EXPECT_EQ("", fred.First(0));
720 EXPECT_EQ("F", fred.First(1));
721 EXPECT_EQ("FR", fred.First(2));
722 EXPECT_EQ("FRE", fred.First(3));
723 EXPECT_EQ("FRED", fred.First(4));
724
725 EXPECT_EQ("", fred.First(5));
726
727 ByteString empty;
728 EXPECT_EQ("", empty.First(0));
729 EXPECT_EQ("", empty.First(1));
730}
731
732TEST(ByteString, Last) {
733 ByteString fred("FRED");
734 EXPECT_EQ("", fred.Last(0));
735 EXPECT_EQ("D", fred.Last(1));
736 EXPECT_EQ("ED", fred.Last(2));
737 EXPECT_EQ("RED", fred.Last(3));
738 EXPECT_EQ("FRED", fred.Last(4));
739
740 EXPECT_EQ("", fred.Last(5));
741
742 ByteString empty;
743 EXPECT_EQ("", empty.Last(0));
744 EXPECT_EQ("", empty.Last(1));
745}
746
747TEST(ByteString, Find) {
748 ByteString null_string;
749 EXPECT_FALSE(null_string.Find('a').has_value());
750 EXPECT_FALSE(null_string.Find('\0').has_value());
751
752 ByteString empty_string("");
753 EXPECT_FALSE(empty_string.Find('a').has_value());
754 EXPECT_FALSE(empty_string.Find('\0').has_value());
755
756 ByteString single_string("a");
757 std::optional<size_t> result = single_string.Find('a');
758 ASSERT_TRUE(result.has_value());
759 EXPECT_EQ(0u, result.value());
760 EXPECT_FALSE(single_string.Find('b').has_value());
761 EXPECT_FALSE(single_string.Find('\0').has_value());
762
763 ByteString longer_string("abccc");
764 result = longer_string.Find('a');
765 ASSERT_TRUE(result.has_value());
766 EXPECT_EQ(0u, result.value());
767 result = longer_string.Find('c');
768 ASSERT_TRUE(result.has_value());
769 EXPECT_EQ(2u, result.value());
770 result = longer_string.Find('c', 3);
771 ASSERT_TRUE(result.has_value());
772 EXPECT_EQ(3u, result.value());
773 EXPECT_FALSE(longer_string.Find('d').has_value());
774 EXPECT_FALSE(longer_string.Find('\0').has_value());
775
776 result = longer_string.Find("ab");
777 ASSERT_TRUE(result.has_value());
778 EXPECT_EQ(0u, result.value());
779 result = longer_string.Find("ccc");
780 ASSERT_TRUE(result.has_value());
781 EXPECT_EQ(2u, result.value());
782 result = longer_string.Find("cc", 3);
783 ASSERT_TRUE(result.has_value());
784 EXPECT_EQ(3u, result.value());
785 EXPECT_FALSE(longer_string.Find("d").has_value());
786
787 ByteString hibyte_string(
788 "ab\x8c"
789 "def");
790 result = hibyte_string.Find('\x8c');
791 ASSERT_TRUE(result.has_value());
792 EXPECT_EQ(2u, result.value());
793}
794
795TEST(ByteString, ReverseFind) {
796 ByteString null_string;
797 EXPECT_FALSE(null_string.ReverseFind('a').has_value());
798 EXPECT_FALSE(null_string.ReverseFind('\0').has_value());
799
800 ByteString empty_string("");
801 EXPECT_FALSE(empty_string.ReverseFind('a').has_value());
802 EXPECT_FALSE(empty_string.ReverseFind('\0').has_value());
803
804 ByteString single_string("a");
805 std::optional<size_t> result = single_string.ReverseFind('a');
806 ASSERT_TRUE(result.has_value());
807 EXPECT_EQ(0u, result.value());
808 EXPECT_FALSE(single_string.ReverseFind('b').has_value());
809 EXPECT_FALSE(single_string.ReverseFind('\0').has_value());
810
811 ByteString longer_string("abccc");
812 result = longer_string.ReverseFind('a');
813 ASSERT_TRUE(result.has_value());
814 EXPECT_EQ(0u, result.value());
815 result = longer_string.ReverseFind('c');
816 ASSERT_TRUE(result.has_value());
817 EXPECT_EQ(4u, result.value());
818 EXPECT_FALSE(longer_string.ReverseFind('\0').has_value());
819
820 ByteString hibyte_string(
821 "ab\x8c"
822 "def");
823 result = hibyte_string.ReverseFind('\x8c');
824 ASSERT_TRUE(result.has_value());
825 EXPECT_EQ(2u, result.value());
826}
827
828TEST(ByteString, UpperLower) {
829 ByteString fred("F-Re.42D");
830 fred.MakeLower();
831 EXPECT_EQ("f-re.42d", fred);
832 fred.MakeUpper();
833 EXPECT_EQ("F-RE.42D", fred);
834
835 ByteString empty;
836 empty.MakeLower();
837 EXPECT_EQ("", empty);
838 empty.MakeUpper();
839 EXPECT_EQ("", empty);
840
841 ByteString empty_with_buffer("x");
842 empty_with_buffer.Delete(0);
843
844 ByteString additional_empty_with_buffer_ref = empty_with_buffer;
845 additional_empty_with_buffer_ref.MakeLower();
846 EXPECT_EQ("", additional_empty_with_buffer_ref);
847
848 additional_empty_with_buffer_ref = empty_with_buffer;
849 additional_empty_with_buffer_ref.MakeUpper();
850 EXPECT_EQ("", additional_empty_with_buffer_ref);
851}
852
853TEST(ByteString, Trim) {
854 ByteString fred(" FRED ");
855 fred.TrimWhitespace();
856 EXPECT_EQ("FRED", fred);
857 fred.Trim('E');
858 EXPECT_EQ("FRED", fred);
859 fred.Trim('F');
860 EXPECT_EQ("RED", fred);
861 fred.Trim("ERP");
862 EXPECT_EQ("D", fred);
863
864 ByteString blank(" ");
865 blank.Trim("ERP");
866 EXPECT_EQ(" ", blank);
867 blank.Trim('E');
868 EXPECT_EQ(" ", blank);
869 blank.TrimWhitespace();
870 EXPECT_EQ("", blank);
871
872 ByteString empty;
873 empty.Trim("ERP");
874 EXPECT_EQ("", empty);
875 empty.Trim('E');
876 EXPECT_EQ("", empty);
877 empty.TrimWhitespace();
878 EXPECT_EQ("", empty);
879
880 ByteString abc(" ABCCBA ");
881 abc.Trim("A");
882 EXPECT_EQ(" ABCCBA ", abc);
883 abc.Trim(" A");
884 EXPECT_EQ("BCCB", abc);
885}
886
887TEST(ByteString, TrimFront) {
888 ByteString fred(" FRED ");
889 fred.TrimWhitespaceFront();
890 EXPECT_EQ("FRED ", fred);
891 fred.TrimFront('E');
892 EXPECT_EQ("FRED ", fred);
893 fred.TrimFront('F');
894 EXPECT_EQ("RED ", fred);
895 fred.TrimFront("ERP");
896 EXPECT_EQ("D ", fred);
897
898 ByteString blank(" ");
899 blank.TrimFront("ERP");
900 EXPECT_EQ(" ", blank);
901 blank.TrimFront('E');
902 EXPECT_EQ(" ", blank);
903 blank.TrimWhitespaceFront();
904 EXPECT_EQ("", blank);
905
906 ByteString empty;
907 empty.TrimFront("ERP");
908 EXPECT_EQ("", empty);
909 empty.TrimFront('E');
910 EXPECT_EQ("", empty);
911 empty.TrimWhitespaceFront();
912 EXPECT_EQ("", empty);
913}
914
915TEST(ByteString, TrimFrontCopies) {
916 {
917 // With a single reference, no copy takes place.
918 ByteString fred(" FRED ");
919 const char* old_buffer = fred.c_str();
920 fred.TrimWhitespaceFront();
921 EXPECT_EQ("FRED ", fred);
922 EXPECT_EQ(old_buffer, fred.c_str());
923 }
924 {
925 // With multiple references, we must copy.
926 ByteString fred(" FRED ");
927 ByteString other_fred = fred;
928 const char* old_buffer = fred.c_str();
929 fred.TrimWhitespaceFront();
930 EXPECT_EQ("FRED ", fred);
931 EXPECT_EQ(" FRED ", other_fred);
932 EXPECT_NE(old_buffer, fred.c_str());
933 }
934 {
935 // With multiple references, but no modifications, no copy.
936 ByteString fred("FRED");
937 ByteString other_fred = fred;
938 const char* old_buffer = fred.c_str();
939 fred.TrimWhitespaceFront();
940 EXPECT_EQ("FRED", fred);
941 EXPECT_EQ("FRED", other_fred);
942 EXPECT_EQ(old_buffer, fred.c_str());
943 }
944}
945
946TEST(ByteString, TrimBack) {
947 ByteString fred(" FRED ");
948 fred.TrimWhitespaceBack();
949 EXPECT_EQ(" FRED", fred);
950 fred.TrimBack('E');
951 EXPECT_EQ(" FRED", fred);
952 fred.TrimBack('D');
953 EXPECT_EQ(" FRE", fred);
954 fred.TrimBack("ERP");
955 EXPECT_EQ(" F", fred);
956
957 ByteString blank(" ");
958 blank.TrimBack("ERP");
959 EXPECT_EQ(" ", blank);
960 blank.TrimBack('E');
961 EXPECT_EQ(" ", blank);
962 blank.TrimWhitespaceBack();
963 EXPECT_EQ("", blank);
964
965 ByteString empty;
966 empty.TrimBack("ERP");
967 EXPECT_EQ("", empty);
968 empty.TrimBack('E');
969 EXPECT_EQ("", empty);
970 empty.TrimWhitespaceBack();
971 EXPECT_EQ("", empty);
972}
973
974TEST(ByteString, TrimBackCopies) {
975 {
976 // With a single reference, no copy takes place.
977 ByteString fred(" FRED ");
978 const char* old_buffer = fred.c_str();
979 fred.TrimWhitespaceBack();
980 EXPECT_EQ(" FRED", fred);
981 EXPECT_EQ(old_buffer, fred.c_str());
982 }
983 {
984 // With multiple references, we must copy.
985 ByteString fred(" FRED ");
986 ByteString other_fred = fred;
987 const char* old_buffer = fred.c_str();
988 fred.TrimWhitespaceBack();
989 EXPECT_EQ(" FRED", fred);
990 EXPECT_EQ(" FRED ", other_fred);
991 EXPECT_NE(old_buffer, fred.c_str());
992 }
993 {
994 // With multiple references, but no modifications, no copy.
995 ByteString fred("FRED");
996 ByteString other_fred = fred;
997 const char* old_buffer = fred.c_str();
998 fred.TrimWhitespaceBack();
999 EXPECT_EQ("FRED", fred);
1000 EXPECT_EQ("FRED", other_fred);
1001 EXPECT_EQ(old_buffer, fred.c_str());
1002 }
1003}
1004
1005TEST(ByteString, Reserve) {
1006 {
1007 ByteString str;
1008 str.Reserve(6);
1009 const char* old_buffer = str.c_str();
1010 str += "ABCDEF";
1011 EXPECT_EQ(old_buffer, str.c_str());
1012 str += "Blah Blah Blah Blah Blah Blah";
1013 EXPECT_NE(old_buffer, str.c_str());
1014 }
1015 {
1016 ByteString str("A");
1017 str.Reserve(6);
1018 const char* old_buffer = str.c_str();
1019 str += "BCDEF";
1020 EXPECT_EQ(old_buffer, str.c_str());
1021 str += "Blah Blah Blah Blah Blah Blah";
1022 EXPECT_NE(old_buffer, str.c_str());
1023 }
1024}
1025
1026TEST(ByteString, GetBuffer) {
1027 ByteString str1;
1028 {
1029 pdfium::span<char> buffer = str1.GetBuffer(12);
1030 // NOLINTNEXTLINE(runtime/printf)
1031 strcpy(buffer.data(), "clams");
1032 }
1033 str1.ReleaseBuffer(str1.GetStringLength());
1034 EXPECT_EQ("clams", str1);
1035
1036 ByteString str2("cl");
1037 {
1038 pdfium::span<char> buffer = str2.GetBuffer(12);
1039 // NOLINTNEXTLINE(runtime/printf)
1040 strcpy(&buffer[2], "ams");
1041 }
1042 str2.ReleaseBuffer(str2.GetStringLength());
1043 EXPECT_EQ("clams", str2);
1044}
1045
1046TEST(ByteString, ReleaseBuffer) {
1047 {
1048 ByteString str;
1049 str.Reserve(12);
1050 str += "clams";
1051 const char* old_buffer = str.c_str();
1052 str.ReleaseBuffer(4);
1053 EXPECT_EQ(old_buffer, str.c_str());
1054 EXPECT_EQ("clam", str);
1055 }
1056 {
1057 ByteString str("c");
1058 str.Reserve(12);
1059 str += "lams";
1060 const char* old_buffer = str.c_str();
1061 str.ReleaseBuffer(4);
1062 EXPECT_EQ(old_buffer, str.c_str());
1063 EXPECT_EQ("clam", str);
1064 }
1065 {
1066 ByteString str;
1067 str.Reserve(200);
1068 str += "clams";
1069 const char* old_buffer = str.c_str();
1070 str.ReleaseBuffer(4);
1071 EXPECT_NE(old_buffer, str.c_str());
1072 EXPECT_EQ("clam", str);
1073 }
1074 {
1075 ByteString str("c");
1076 str.Reserve(200);
1077 str += "lams";
1078 const char* old_buffer = str.c_str();
1079 str.ReleaseBuffer(4);
1080 EXPECT_NE(old_buffer, str.c_str());
1081 EXPECT_EQ("clam", str);
1082 }
1083}
1084
1085TEST(ByteString, EmptyReverseIterator) {
1086 ByteString empty;
1087 auto iter = empty.rbegin();
1088 EXPECT_TRUE(iter == empty.rend());
1089 EXPECT_FALSE(iter != empty.rend());
1090 EXPECT_FALSE(iter < empty.rend());
1091}
1092
1093TEST(ByteString, OneCharReverseIterator) {
1094 ByteString one_str("a");
1095 auto iter = one_str.rbegin();
1096 EXPECT_FALSE(iter == one_str.rend());
1097 EXPECT_TRUE(iter != one_str.rend());
1098 EXPECT_TRUE(iter < one_str.rend());
1099
1100 char ch = *iter++;
1101 EXPECT_EQ('a', ch);
1102 EXPECT_TRUE(iter == one_str.rend());
1103 EXPECT_FALSE(iter != one_str.rend());
1104 EXPECT_FALSE(iter < one_str.rend());
1105}
1106
1107TEST(ByteString, MultiCharReverseIterator) {
1108 ByteString multi_str("abcd");
1109 auto iter = multi_str.rbegin();
1110 EXPECT_NE(iter, multi_str.rend());
1111 EXPECT_EQ(4, multi_str.rend() - iter);
1112 EXPECT_EQ(0, iter - multi_str.rbegin());
1113
1114 char ch = *iter++;
1115 EXPECT_EQ('d', ch);
1116 EXPECT_EQ('c', *iter);
1117 EXPECT_NE(iter, multi_str.rend());
1118 EXPECT_EQ(3, multi_str.rend() - iter);
1119 EXPECT_EQ(1, iter - multi_str.rbegin());
1120
1121 ch = *(++iter);
1122 EXPECT_EQ('b', ch);
1123 EXPECT_EQ('b', *iter);
1124 EXPECT_NE(iter, multi_str.rend());
1125 EXPECT_EQ(2, multi_str.rend() - iter);
1126 EXPECT_EQ(2, iter - multi_str.rbegin());
1127
1128 ch = *iter++;
1129 EXPECT_EQ('b', ch);
1130 EXPECT_EQ('a', *iter);
1131 EXPECT_NE(iter, multi_str.rend());
1132 EXPECT_EQ(1, multi_str.rend() - iter);
1133 EXPECT_EQ(3, iter - multi_str.rbegin());
1134
1135 ch = *iter++;
1136 EXPECT_EQ('a', ch);
1137 EXPECT_EQ(iter, multi_str.rend());
1138 EXPECT_EQ(0, multi_str.rend() - iter);
1139 EXPECT_EQ(4, iter - multi_str.rbegin());
1140
1141 ch = *(--iter);
1142 EXPECT_EQ('a', ch);
1143 EXPECT_EQ('a', *iter);
1144 EXPECT_NE(iter, multi_str.rend());
1145 EXPECT_EQ(1, multi_str.rend() - iter);
1146 EXPECT_EQ(3, iter - multi_str.rbegin());
1147
1148 ch = *iter--;
1149 EXPECT_EQ('a', ch);
1150 EXPECT_EQ('b', *iter);
1151 EXPECT_NE(iter, multi_str.rend());
1152 EXPECT_EQ(2, multi_str.rend() - iter);
1153 EXPECT_EQ(2, iter - multi_str.rbegin());
1154
1155 ch = *iter--;
1156 EXPECT_EQ('b', ch);
1157 EXPECT_EQ('c', *iter);
1158 EXPECT_NE(iter, multi_str.rend());
1159 EXPECT_EQ(3, multi_str.rend() - iter);
1160 EXPECT_EQ(1, iter - multi_str.rbegin());
1161
1162 ch = *(--iter);
1163 EXPECT_EQ('d', ch);
1164 EXPECT_EQ('d', *iter);
1165 EXPECT_EQ(iter, multi_str.rbegin());
1166 EXPECT_EQ(4, multi_str.rend() - iter);
1167 EXPECT_EQ(0, iter - multi_str.rbegin());
1168}
1169
1170TEST(ByteStringView, Null) {
1171 ByteStringView null_string;
1172 EXPECT_FALSE(null_string.unterminated_unsigned_str());
1173 EXPECT_EQ(0u, null_string.GetLength());
1174 EXPECT_TRUE(null_string.IsEmpty());
1175
1176 ByteStringView another_null_string;
1177 EXPECT_EQ(null_string, another_null_string);
1178
1179 ByteStringView copied_null_string(null_string);
1180 EXPECT_FALSE(copied_null_string.unterminated_unsigned_str());
1181 EXPECT_EQ(0u, copied_null_string.GetLength());
1182 EXPECT_TRUE(copied_null_string.IsEmpty());
1183 EXPECT_EQ(null_string, copied_null_string);
1184
1185 auto span_null_string = ByteStringView(pdfium::span<const uint8_t>());
1186 EXPECT_FALSE(span_null_string.unterminated_unsigned_str());
1187 EXPECT_EQ(0u, span_null_string.GetLength());
1188 EXPECT_TRUE(span_null_string.IsEmpty());
1189 EXPECT_EQ(null_string, span_null_string);
1190
1191 ByteStringView empty_string(""); // Pointer to NUL, not NULL pointer.
1192 EXPECT_TRUE(empty_string.unterminated_unsigned_str());
1193 EXPECT_EQ(0u, empty_string.GetLength());
1194 EXPECT_TRUE(empty_string.IsEmpty());
1195 EXPECT_EQ(null_string, empty_string);
1196
1197 ByteStringView assigned_null_string("initially not nullptr");
1198 assigned_null_string = null_string;
1199 EXPECT_FALSE(assigned_null_string.unterminated_unsigned_str());
1200 EXPECT_EQ(0u, assigned_null_string.GetLength());
1201 EXPECT_TRUE(assigned_null_string.IsEmpty());
1202 EXPECT_EQ(null_string, assigned_null_string);
1203
1204 ByteStringView assigned_nullptr_string("initially not nullptr");
1205 assigned_nullptr_string = nullptr;
1206 EXPECT_FALSE(assigned_nullptr_string.unterminated_unsigned_str());
1207 EXPECT_EQ(0u, assigned_nullptr_string.GetLength());
1208 EXPECT_TRUE(assigned_nullptr_string.IsEmpty());
1209 EXPECT_EQ(null_string, assigned_nullptr_string);
1210
1211 ByteStringView assigned_span_null_string("initially not null span");
1212 assigned_span_null_string = ByteStringView(pdfium::span<const uint8_t>());
1213 EXPECT_FALSE(assigned_span_null_string.unterminated_unsigned_str());
1214 EXPECT_EQ(0u, assigned_span_null_string.GetLength());
1215 EXPECT_TRUE(assigned_span_null_string.IsEmpty());
1216 EXPECT_EQ(null_string, assigned_span_null_string);
1217
1218 ByteStringView non_null_string("a");
1219 EXPECT_NE(null_string, non_null_string);
1220}
1221
1222TEST(ByteStringView, NotNull) {
1223 ByteStringView string3("abc");
1224 ByteStringView string6("abcdef");
1225 // SAFETY: known fixed-length string.
1226 auto alternate_string3 = UNSAFE_BUFFERS(ByteStringView("abcdef", 3));
1227 const char abcd[] = "abcd";
1228 ByteStringView span_string4(
1229 pdfium::as_bytes(pdfium::make_span(abcd).first(4u)));
1230 // SAFETY: known fixed-length string.
1231 auto embedded_nul_string7 = UNSAFE_BUFFERS(ByteStringView("abc\0def", 7));
1232 // SAFETY: known fixed-length string.
1233 auto illegal_string7 = UNSAFE_BUFFERS(ByteStringView("abcdef", 7));
1234
1235 EXPECT_EQ(3u, string3.GetLength());
1236 EXPECT_EQ(6u, string6.GetLength());
1237 EXPECT_EQ(3u, alternate_string3.GetLength());
1238 EXPECT_EQ(4u, span_string4.GetLength());
1239 EXPECT_EQ(7u, embedded_nul_string7.GetLength());
1240 EXPECT_EQ(7u, illegal_string7.GetLength());
1241
1242 EXPECT_NE(string3, string6);
1243 EXPECT_EQ(string3, alternate_string3);
1244 EXPECT_NE(string3, embedded_nul_string7);
1245 EXPECT_NE(string3, illegal_string7);
1246 EXPECT_NE(string6, alternate_string3);
1247 EXPECT_NE(string6, embedded_nul_string7);
1248 EXPECT_NE(string6, illegal_string7);
1249 EXPECT_NE(alternate_string3, embedded_nul_string7);
1250 EXPECT_NE(alternate_string3, illegal_string7);
1251 EXPECT_NE(embedded_nul_string7, illegal_string7);
1252
1253 ByteStringView copied_string3(string3);
1254 ByteStringView copied_alternate_string3(alternate_string3);
1255 ByteStringView copied_embedded_nul_string7(embedded_nul_string7);
1256
1257 EXPECT_EQ(string3, copied_string3);
1258 EXPECT_EQ(alternate_string3, copied_alternate_string3);
1259 EXPECT_EQ(embedded_nul_string7, copied_embedded_nul_string7);
1260
1261 ByteStringView assigned_string3("intially something else");
1262 ByteStringView assigned_alternate_string3("initally something else");
1263 ByteStringView assigned_ptr_string3("initially something else");
1264 ByteStringView assigned_embedded_nul_string7("initially something else");
1265
1266 assigned_string3 = string3;
1267 assigned_alternate_string3 = alternate_string3;
1268 assigned_ptr_string3 = "abc";
1269 assigned_embedded_nul_string7 = embedded_nul_string7;
1270 EXPECT_EQ(string3, assigned_string3);
1271 EXPECT_EQ(alternate_string3, assigned_alternate_string3);
1272 EXPECT_EQ(alternate_string3, assigned_ptr_string3);
1273 EXPECT_EQ(embedded_nul_string7, assigned_embedded_nul_string7);
1274}
1275
1276TEST(ByteStringView, FromChar) {
1277 ByteStringView null_string;
1278 ByteStringView lower_a_string("a");
1279
1280 // Must have lvalues that outlive the corresponding ByteStringC.
1281 char nul = '\0';
1282 char lower_a = 'a';
1283 ByteStringView nul_string_from_char(nul);
1284 ByteStringView lower_a_string_from_char(lower_a);
1285
1286 // Pointer to nul, not nullptr ptr, hence length 1 ...
1287 EXPECT_EQ(1u, nul_string_from_char.GetLength());
1288 EXPECT_NE(null_string, nul_string_from_char);
1289
1290 EXPECT_EQ(1u, lower_a_string_from_char.GetLength());
1291 EXPECT_EQ(lower_a_string, lower_a_string_from_char);
1292 EXPECT_NE(nul_string_from_char, lower_a_string_from_char);
1293
1294 ByteStringView longer_string("ab");
1295 EXPECT_NE(longer_string, lower_a_string_from_char);
1296}
1297
1298TEST(ByteStringView, FromVector) {
1299 std::vector<uint8_t> null_vec;
1300 ByteStringView null_string(null_vec);
1301 EXPECT_EQ(0u, null_string.GetLength());
1302
1303 std::vector<uint8_t> lower_a_vec(10, static_cast<uint8_t>('a'));
1304 ByteStringView lower_a_string(lower_a_vec);
1305 EXPECT_EQ(static_cast<size_t>(10), lower_a_string.GetLength());
1306 EXPECT_EQ("aaaaaaaaaa", lower_a_string);
1307
1308 std::vector<uint8_t> cleared_vec;
1309 cleared_vec.push_back(42);
1310 cleared_vec.pop_back();
1311 ByteStringView cleared_string(cleared_vec);
1312 EXPECT_EQ(0u, cleared_string.GetLength());
1313 EXPECT_FALSE(cleared_string.unterminated_unsigned_str());
1314}
1315
1316TEST(ByteStringView, GetID) {
1317 ByteStringView null_string;
1318 EXPECT_EQ(0u, null_string.GetID());
1319
1320 ByteStringView empty_string("");
1321 EXPECT_EQ(0u, empty_string.GetID());
1322
1323 ByteStringView short_string("ab");
1324 EXPECT_EQ(FXBSTR_ID('a', 'b', 0, 0), short_string.GetID());
1325
1326 ByteStringView longer_string("abcdef");
1327 EXPECT_EQ(FXBSTR_ID('a', 'b', 'c', 'd'), longer_string.GetID());
1328}
1329
1330TEST(ByteStringView, Find) {
1331 ByteStringView null_string;
1332 EXPECT_FALSE(null_string.Find('a').has_value());
1333 EXPECT_FALSE(null_string.Find('\0').has_value());
1334
1335 ByteStringView empty_string("");
1336 EXPECT_FALSE(empty_string.Find('a').has_value());
1337 EXPECT_FALSE(empty_string.Find('\0').has_value());
1338
1339 ByteStringView single_string("a");
1340 std::optional<size_t> result = single_string.Find('a');
1341 ASSERT_TRUE(result.has_value());
1342 EXPECT_EQ(0u, result.value());
1343 EXPECT_FALSE(single_string.Find('b').has_value());
1344 EXPECT_FALSE(single_string.Find('\0').has_value());
1345
1346 ByteStringView longer_string("abccc");
1347 result = longer_string.Find('a');
1348 ASSERT_TRUE(result.has_value());
1349 EXPECT_EQ(0u, result.value());
1350 result = longer_string.Find('c');
1351 ASSERT_TRUE(result.has_value());
1352 EXPECT_EQ(2u, result.value());
1353 EXPECT_FALSE(longer_string.Find('d').has_value());
1354 EXPECT_FALSE(longer_string.Find('\0').has_value());
1355
1356 ByteStringView hibyte_string(
1357 "ab\x8c"
1358 "def");
1359 result = hibyte_string.Find('\x8c');
1360 ASSERT_TRUE(result.has_value());
1361 EXPECT_EQ(2u, result.value());
1362}
1363
1364TEST(ByteStringView, OneArgSubstr) {
1365 ByteStringView null_string;
1366 EXPECT_EQ(null_string, null_string.Substr(0));
1367 EXPECT_EQ(null_string, null_string.Substr(1));
1368
1369 ByteStringView empty_string("");
1370 EXPECT_EQ("", empty_string.Substr(0));
1371 EXPECT_EQ("", empty_string.Substr(1));
1372
1373 ByteStringView single_character("a");
1374 EXPECT_EQ(single_character, single_character.Substr(0));
1375 EXPECT_EQ("", single_character.Substr(1));
1376
1377 ByteStringView longer_string("abcdef");
1378 EXPECT_EQ(longer_string, longer_string.Substr(0));
1379 EXPECT_EQ("", longer_string.Substr(187));
1380
1381 ByteStringView trailing_substring("ef");
1382 EXPECT_EQ(trailing_substring, longer_string.Substr(4));
1383}
1384
1385TEST(ByteStringView, TwoArgSubstr) {
1386 ByteStringView null_string;
1387 EXPECT_EQ(null_string, null_string.Substr(0, 1));
1388 EXPECT_EQ(null_string, null_string.Substr(1, 1));
1389
1390 ByteStringView empty_string("");
1391 EXPECT_EQ("", empty_string.Substr(0, 1));
1392 EXPECT_EQ("", empty_string.Substr(1, 1));
1393
1394 ByteStringView single_character("a");
1395 EXPECT_EQ("", single_character.Substr(0, 0));
1396 EXPECT_EQ(single_character, single_character.Substr(0, 1));
1397 EXPECT_EQ("", single_character.Substr(1, 0));
1398 EXPECT_EQ("", single_character.Substr(1, 1));
1399
1400 ByteStringView longer_string("abcdef");
1401 EXPECT_EQ(longer_string, longer_string.Substr(0, 6));
1402 EXPECT_EQ("", longer_string.Substr(0, 187));
1403
1404 ByteStringView leading_substring("ab");
1405 EXPECT_EQ(leading_substring, longer_string.Substr(0, 2));
1406
1407 ByteStringView middle_substring("bcde");
1408 EXPECT_EQ(middle_substring, longer_string.Substr(1, 4));
1409
1410 ByteStringView trailing_substring("ef");
1411 EXPECT_EQ(trailing_substring, longer_string.Substr(4, 2));
1412 EXPECT_EQ("", longer_string.Substr(4, 3));
1413}
1414
1415TEST(ByteStringView, TrimmedRight) {
1416 ByteStringView fred("FRED");
1417 EXPECT_EQ("FRED", fred.TrimmedRight('E'));
1418 EXPECT_EQ("FRE", fred.TrimmedRight('D'));
1419 ByteStringView fredd("FREDD");
1420 EXPECT_EQ("FRE", fredd.TrimmedRight('D'));
1421}
1422
1423TEST(ByteStringView, ElementAccess) {
1424 // ByteStringView includes the NUL terminator for non-empty strings.
1425 ByteStringView abc("abc");
1426 EXPECT_EQ('a', static_cast<char>(abc[0]));
1427 EXPECT_EQ('b', static_cast<char>(abc[1]));
1428 EXPECT_EQ('c', static_cast<char>(abc[2]));
1429#ifndef NDEBUG
1430 EXPECT_DEATH({ abc[3]; }, "");
1431#endif
1432}
1433
1434TEST(ByteStringView, OperatorLT) {
1435 ByteStringView empty;
1436 ByteStringView a("a");
1437 ByteStringView abc("abc");
1438 ByteStringView def("def");
1439 const char* const c_null = nullptr;
1440 const char* const c_empty = "";
1441 const char* const c_a = "a";
1442 const char* const c_abc = "abc";
1443 const char* const c_def = "def";
1444
1445 EXPECT_FALSE(empty < empty);
1446 EXPECT_FALSE(a < a);
1447 EXPECT_FALSE(abc < abc);
1448 EXPECT_FALSE(def < def);
1449 EXPECT_FALSE(c_null < empty);
1450 EXPECT_FALSE(c_empty < empty);
1451 EXPECT_FALSE(c_a < a);
1452 EXPECT_FALSE(c_abc < abc);
1453 EXPECT_FALSE(c_def < def);
1454 EXPECT_FALSE(empty < c_null);
1455 EXPECT_FALSE(empty < c_empty);
1456 EXPECT_FALSE(a < c_a);
1457 EXPECT_FALSE(abc < c_abc);
1458 EXPECT_FALSE(def < c_def);
1459
1460 EXPECT_TRUE(empty < a);
1461 EXPECT_FALSE(a < empty);
1462 EXPECT_TRUE(empty < c_a);
1463 EXPECT_FALSE(a < c_null);
1464 EXPECT_FALSE(a < c_empty);
1465
1466 EXPECT_TRUE(empty < abc);
1467 EXPECT_FALSE(abc < empty);
1468 EXPECT_TRUE(empty < c_abc);
1469 EXPECT_FALSE(abc < c_null);
1470 EXPECT_FALSE(abc < c_empty);
1471
1472 EXPECT_TRUE(empty < def);
1473 EXPECT_FALSE(def < empty);
1474 EXPECT_TRUE(empty < c_def);
1475 EXPECT_FALSE(def < c_null);
1476 EXPECT_FALSE(def < c_empty);
1477
1478 EXPECT_TRUE(a < abc);
1479 EXPECT_FALSE(abc < a);
1480 EXPECT_TRUE(a < c_abc);
1481 EXPECT_FALSE(abc < c_a);
1482
1483 EXPECT_TRUE(a < def);
1484 EXPECT_FALSE(def < a);
1485 EXPECT_TRUE(a < c_def);
1486 EXPECT_FALSE(def < c_a);
1487
1488 EXPECT_TRUE(abc < def);
1489 EXPECT_FALSE(def < abc);
1490 EXPECT_TRUE(abc < c_def);
1491 EXPECT_FALSE(def < c_abc);
1492}
1493
1494TEST(ByteStringView, OperatorEQ) {
1495 ByteStringView byte_string_c("hello");
1496 EXPECT_TRUE(byte_string_c == byte_string_c);
1497
1498 ByteStringView byte_string_c_same1("hello");
1499 EXPECT_TRUE(byte_string_c == byte_string_c_same1);
1500 EXPECT_TRUE(byte_string_c_same1 == byte_string_c);
1501
1502 ByteStringView byte_string_c_same2(byte_string_c);
1503 EXPECT_TRUE(byte_string_c == byte_string_c_same2);
1504 EXPECT_TRUE(byte_string_c_same2 == byte_string_c);
1505
1506 ByteStringView byte_string_c1("he");
1507 ByteStringView byte_string_c2("hellp");
1508 ByteStringView byte_string_c3("hellod");
1509 EXPECT_FALSE(byte_string_c == byte_string_c1);
1510 EXPECT_FALSE(byte_string_c == byte_string_c2);
1511 EXPECT_FALSE(byte_string_c == byte_string_c3);
1512 EXPECT_FALSE(byte_string_c1 == byte_string_c);
1513 EXPECT_FALSE(byte_string_c2 == byte_string_c);
1514 EXPECT_FALSE(byte_string_c3 == byte_string_c);
1515
1516 ByteString byte_string_same1("hello");
1517 EXPECT_TRUE(byte_string_c == byte_string_same1);
1518 EXPECT_TRUE(byte_string_same1 == byte_string_c);
1519
1520 ByteString byte_string1("he");
1521 ByteString byte_string2("hellp");
1522 ByteString byte_string3("hellod");
1523 EXPECT_FALSE(byte_string_c == byte_string1);
1524 EXPECT_FALSE(byte_string_c == byte_string2);
1525 EXPECT_FALSE(byte_string_c == byte_string3);
1526 EXPECT_FALSE(byte_string1 == byte_string_c);
1527 EXPECT_FALSE(byte_string2 == byte_string_c);
1528 EXPECT_FALSE(byte_string3 == byte_string_c);
1529
1530 const char* const c_string_same1 = "hello";
1531 EXPECT_TRUE(byte_string_c == c_string_same1);
1532 EXPECT_TRUE(c_string_same1 == byte_string_c);
1533
1534 const char* const c_string1 = "he";
1535 const char* const c_string2 = "hellp";
1536 const char* const c_string3 = "hellod";
1537 EXPECT_FALSE(byte_string_c == c_string1);
1538 EXPECT_FALSE(byte_string_c == c_string2);
1539 EXPECT_FALSE(byte_string_c == c_string3);
1540
1541 EXPECT_FALSE(c_string1 == byte_string_c);
1542 EXPECT_FALSE(c_string2 == byte_string_c);
1543 EXPECT_FALSE(c_string3 == byte_string_c);
1544
1545 const char kHello[] = "hello";
1546 pdfium::span<const uint8_t> span5(
1547 pdfium::as_bytes(pdfium::make_span(kHello).first(5u)));
1548 auto raw_span = byte_string_c.unsigned_span();
1549 EXPECT_TRUE(
1550 std::equal(raw_span.begin(), raw_span.end(), span5.begin(), span5.end()));
1551}
1552
1553TEST(ByteStringView, OperatorNE) {
1554 ByteStringView byte_string_c("hello");
1555 EXPECT_FALSE(byte_string_c != byte_string_c);
1556
1557 ByteStringView byte_string_c_same1("hello");
1558 EXPECT_FALSE(byte_string_c != byte_string_c_same1);
1559 EXPECT_FALSE(byte_string_c_same1 != byte_string_c);
1560
1561 ByteStringView byte_string_c_same2(byte_string_c);
1562 EXPECT_FALSE(byte_string_c != byte_string_c_same2);
1563 EXPECT_FALSE(byte_string_c_same2 != byte_string_c);
1564
1565 ByteStringView byte_string_c1("he");
1566 ByteStringView byte_string_c2("hellp");
1567 ByteStringView byte_string_c3("hellod");
1568 EXPECT_TRUE(byte_string_c != byte_string_c1);
1569 EXPECT_TRUE(byte_string_c != byte_string_c2);
1570 EXPECT_TRUE(byte_string_c != byte_string_c3);
1571 EXPECT_TRUE(byte_string_c1 != byte_string_c);
1572 EXPECT_TRUE(byte_string_c2 != byte_string_c);
1573 EXPECT_TRUE(byte_string_c3 != byte_string_c);
1574
1575 ByteString byte_string_same1("hello");
1576 EXPECT_FALSE(byte_string_c != byte_string_same1);
1577 EXPECT_FALSE(byte_string_same1 != byte_string_c);
1578
1579 ByteString byte_string1("he");
1580 ByteString byte_string2("hellp");
1581 ByteString byte_string3("hellod");
1582 EXPECT_TRUE(byte_string_c != byte_string1);
1583 EXPECT_TRUE(byte_string_c != byte_string2);
1584 EXPECT_TRUE(byte_string_c != byte_string3);
1585 EXPECT_TRUE(byte_string1 != byte_string_c);
1586 EXPECT_TRUE(byte_string2 != byte_string_c);
1587 EXPECT_TRUE(byte_string3 != byte_string_c);
1588
1589 const char* const c_string_same1 = "hello";
1590 EXPECT_FALSE(byte_string_c != c_string_same1);
1591 EXPECT_FALSE(c_string_same1 != byte_string_c);
1592
1593 const char* const c_string1 = "he";
1594 const char* const c_string2 = "hellp";
1595 const char* const c_string3 = "hellod";
1596 EXPECT_TRUE(byte_string_c != c_string1);
1597 EXPECT_TRUE(byte_string_c != c_string2);
1598 EXPECT_TRUE(byte_string_c != c_string3);
1599
1600 EXPECT_TRUE(c_string1 != byte_string_c);
1601 EXPECT_TRUE(c_string2 != byte_string_c);
1602 EXPECT_TRUE(c_string3 != byte_string_c);
1603}
1604
1605TEST(ByteStringView, NullIterator) {
1606 ByteStringView null_str;
1607 int32_t sum = 0;
1608 bool any_present = false;
1609 for (const auto& c : null_str) {
1610 sum += c; // Avoid unused arg warnings.
1611 any_present = true;
1612 }
1613 EXPECT_FALSE(any_present);
1614 EXPECT_EQ(0, sum);
1615}
1616
1617TEST(ByteStringView, EmptyIterator) {
1618 ByteStringView empty_str("");
1619 int32_t sum = 0;
1620 bool any_present = false;
1621 for (const auto& c : empty_str) {
1622 any_present = true;
1623 sum += c; // Avoid unused arg warnings.
1624 }
1625 EXPECT_FALSE(any_present);
1626 EXPECT_EQ(0, sum);
1627}
1628
1629TEST(ByteStringView, OneCharIterator) {
1630 ByteStringView one_str("a");
1631 int32_t sum = 0;
1632 bool any_present = false;
1633 for (const auto& c : one_str) {
1634 any_present = true;
1635 sum += c; // Avoid unused arg warnings.
1636 }
1637 EXPECT_TRUE(any_present);
1638 EXPECT_EQ('a', sum);
1639}
1640
1641TEST(ByteStringView, MultiCharIterator) {
1642 ByteStringView one_str("abc");
1643 int32_t sum = 0;
1644 bool any_present = false;
1645 for (const auto& c : one_str) {
1646 any_present = true;
1647 sum += c; // Avoid unused arg warnings.
1648 }
1649 EXPECT_TRUE(any_present);
1650 EXPECT_EQ('a' + 'b' + 'c', sum);
1651}
1652
1653TEST(ByteStringView, EmptyReverseIterator) {
1654 ByteStringView empty;
1655 auto iter = empty.rbegin();
1656 EXPECT_TRUE(iter == empty.rend());
1657 EXPECT_FALSE(iter != empty.rend());
1658 EXPECT_FALSE(iter < empty.rend());
1659}
1660
1661TEST(ByteStringView, OneCharReverseIterator) {
1662 ByteStringView one_str("a");
1663 auto iter = one_str.rbegin();
1664 EXPECT_FALSE(iter == one_str.rend());
1665 EXPECT_TRUE(iter != one_str.rend());
1666 EXPECT_TRUE(iter < one_str.rend());
1667
1668 char ch = *iter++;
1669 EXPECT_EQ('a', ch);
1670 EXPECT_TRUE(iter == one_str.rend());
1671 EXPECT_FALSE(iter != one_str.rend());
1672 EXPECT_FALSE(iter < one_str.rend());
1673}
1674
1675TEST(ByteStringView, MultiCharReverseIterator) {
1676 ByteStringView multi_str("abcd");
1677 auto iter = multi_str.rbegin();
1678 EXPECT_FALSE(iter == multi_str.rend());
1679
1680 char ch = *iter++;
1681 EXPECT_EQ('d', ch);
1682 EXPECT_EQ('c', *iter);
1683 EXPECT_FALSE(iter == multi_str.rend());
1684
1685 ch = *(++iter);
1686 EXPECT_EQ('b', ch);
1687 EXPECT_EQ('b', *iter);
1688 EXPECT_FALSE(iter == multi_str.rend());
1689
1690 ch = *iter++;
1691 EXPECT_EQ('b', ch);
1692 EXPECT_EQ('a', *iter);
1693 EXPECT_FALSE(iter == multi_str.rend());
1694
1695 ch = *iter++;
1696 EXPECT_EQ('a', ch);
1697 EXPECT_TRUE(iter == multi_str.rend());
1698
1699 ch = *(--iter);
1700 EXPECT_EQ('a', ch);
1701 EXPECT_EQ('a', *iter);
1702 EXPECT_FALSE(iter == multi_str.rend());
1703
1704 ch = *iter--;
1705 EXPECT_EQ('a', ch);
1706 EXPECT_EQ('b', *iter);
1707 EXPECT_FALSE(iter == multi_str.rend());
1708
1709 ch = *iter--;
1710 EXPECT_EQ('b', ch);
1711 EXPECT_EQ('c', *iter);
1712 EXPECT_FALSE(iter == multi_str.rend());
1713
1714 ch = *(--iter);
1715 EXPECT_EQ('d', ch);
1716 EXPECT_EQ('d', *iter);
1717 EXPECT_TRUE(iter == multi_str.rbegin());
1718}
1719
1720TEST(ByteStringView, AnyAllNoneOf) {
1721 ByteStringView str("aaaaaaaaaaaaaaaaab");
1722 EXPECT_FALSE(std::all_of(str.begin(), str.end(),
1723 [](const char& c) { return c == 'a'; }));
1724
1725 EXPECT_FALSE(std::none_of(str.begin(), str.end(),
1726 [](const char& c) { return c == 'a'; }));
1727
1728 EXPECT_TRUE(std::any_of(str.begin(), str.end(),
1729 [](const char& c) { return c == 'a'; }));
1730
1731 EXPECT_TRUE(pdfium::Contains(str, 'a'));
1732 EXPECT_TRUE(pdfium::Contains(str, 'b'));
1733 EXPECT_FALSE(pdfium::Contains(str, 'z'));
1734}
1735
1736TEST(ByteString, FormatWidth) {
1737 EXPECT_EQ(" 1", ByteString::Format("%5d", 1));
1738 EXPECT_EQ("1", ByteString::Format("%d", 1));
1739 EXPECT_EQ(" 1", ByteString::Format("%*d", 5, 1));
1740 EXPECT_EQ("1", ByteString::Format("%-1d", 1));
1741 EXPECT_EQ("1", ByteString::Format("%0d", 1));
1742}
1743
1744TEST(ByteString, FormatPrecision) {
1745 EXPECT_EQ("1.12", ByteString::Format("%.2f", 1.12345));
1746 EXPECT_EQ("1.123", ByteString::Format("%.*f", 3, 1.12345));
1747 EXPECT_EQ("1.123450", ByteString::Format("%f", 1.12345));
1748 EXPECT_EQ("1.123450", ByteString::Format("%-1f", 1.12345));
1749 EXPECT_EQ("1.123450", ByteString::Format("%0f", 1.12345));
1750}
1751
1752TEST(ByteString, Empty) {
1753 ByteString empty_str;
1754 EXPECT_TRUE(empty_str.IsEmpty());
1755 EXPECT_EQ(0u, empty_str.GetLength());
1756
1757 const char* cstr = empty_str.c_str();
1758 EXPECT_TRUE(cstr);
1759 EXPECT_EQ(0u, strlen(cstr));
1760
1761 const uint8_t* rstr = empty_str.unsigned_str();
1762 EXPECT_FALSE(rstr);
1763
1764 pdfium::span<const char> cspan = empty_str.span();
1765 EXPECT_TRUE(cspan.empty());
1766 EXPECT_FALSE(cspan.data());
1767
1768 pdfium::span<const uint8_t> rspan = empty_str.unsigned_span();
1769 EXPECT_TRUE(rspan.empty());
1770 EXPECT_FALSE(rspan.data());
1771}
1772
1773TEST(ByteString, InitializerList) {
1774 ByteString many_str({"clams", " and ", "oysters"});
1775 EXPECT_EQ("clams and oysters", many_str);
1776 many_str = {"fish", " and ", "chips", " and ", "soda"};
1777 EXPECT_EQ("fish and chips and soda", many_str);
1778}
1779
1780TEST(ByteString, NullIterator) {
1781 ByteString null_str;
1782 int32_t sum = 0;
1783 bool any_present = false;
1784 for (const auto& c : null_str) {
1785 sum += c; // Avoid unused arg warnings.
1786 any_present = true;
1787 }
1788 EXPECT_FALSE(any_present);
1789 EXPECT_EQ(0, sum);
1790}
1791
1792TEST(ByteString, EmptyIterator) {
1793 ByteString empty_str("");
1794 int32_t sum = 0;
1795 bool any_present = false;
1796 for (const auto& c : empty_str) {
1797 any_present = true;
1798 sum += c; // Avoid unused arg warnings.
1799 }
1800 EXPECT_FALSE(any_present);
1801 EXPECT_EQ(0, sum);
1802}
1803
1804TEST(ByteString, OneCharIterator) {
1805 ByteString one_str("a");
1806 int32_t sum = 0;
1807 bool any_present = false;
1808 for (const auto& c : one_str) {
1809 any_present = true;
1810 sum += c; // Avoid unused arg warnings.
1811 }
1812 EXPECT_TRUE(any_present);
1813 EXPECT_EQ('a', sum);
1814}
1815
1816TEST(ByteString, MultiCharIterator) {
1817 ByteString one_str("abc");
1818 int32_t sum = 0;
1819 bool any_present = false;
1820 for (const auto& c : one_str) {
1821 any_present = true;
1822 sum += c; // Avoid unused arg warnings.
1823 }
1824 EXPECT_TRUE(any_present);
1825 EXPECT_EQ('a' + 'b' + 'c', sum);
1826}
1827
1828TEST(ByteString, StdBegin) {
1829 ByteString one_str("abc");
1830 std::vector<uint8_t> vec(std::begin(one_str), std::end(one_str));
1831 ASSERT_EQ(3u, vec.size());
1832 EXPECT_EQ('a', vec[0]);
1833 EXPECT_EQ('b', vec[1]);
1834 EXPECT_EQ('c', vec[2]);
1835}
1836
1837TEST(ByteString, AnyAllNoneOf) {
1838 ByteString str("aaaaaaaaaaaaaaaaab");
1839 EXPECT_FALSE(std::all_of(str.begin(), str.end(),
1840 [](const char& c) { return c == 'a'; }));
1841
1842 EXPECT_FALSE(std::none_of(str.begin(), str.end(),
1843 [](const char& c) { return c == 'a'; }));
1844
1845 EXPECT_TRUE(std::any_of(str.begin(), str.end(),
1846 [](const char& c) { return c == 'a'; }));
1847
1848 EXPECT_TRUE(pdfium::Contains(str, 'a'));
1849 EXPECT_TRUE(pdfium::Contains(str, 'b'));
1850 EXPECT_FALSE(pdfium::Contains(str, 'z'));
1851}
1852
1853TEST(CFX_BytrString, EqualNoCase) {
1854 ByteString str("aaa");
1855 EXPECT_TRUE(str.EqualNoCase("aaa"));
1856 EXPECT_TRUE(str.EqualNoCase("AAA"));
1857 EXPECT_TRUE(str.EqualNoCase("aaA"));
1858 EXPECT_TRUE(str.EqualNoCase("Aaa"));
1859 EXPECT_FALSE(str.EqualNoCase("aab"));
1860 EXPECT_FALSE(str.EqualNoCase("aaaa"));
1861 EXPECT_FALSE(str.EqualNoCase("BBBB"));
1862 EXPECT_FALSE(str.EqualNoCase("a"));
1863 EXPECT_FALSE(str.EqualNoCase(""));
1864}
1865
1866TEST(ByteString, OStreamOverload) {
1867 std::ostringstream stream;
1868
1869 // Basic case, empty string
1870 ByteString str;
1871 stream << str;
1872 EXPECT_EQ("", stream.str());
1873
1874 // Basic case, non-empty string
1875 str = "def";
1876 stream.str("");
1877 stream << "abc" << str << "ghi";
1878 EXPECT_EQ("abcdefghi", stream.str());
1879
1880 // Changing the ByteString does not change the stream it was written to.
1881 str = "123";
1882 EXPECT_EQ("abcdefghi", stream.str());
1883
1884 // Writing it again to the stream will use the latest value.
1885 stream.str("");
1886 stream << "abc" << str << "ghi";
1887 EXPECT_EQ("abc123ghi", stream.str());
1888
1889 char stringWithNulls[] = {'x', 'y', '\0', 'z'};
1890
1891 // Writing a ByteString with nulls and no specified length treats it as
1892 // a C-style null-terminated string.
1893 str = ByteString(stringWithNulls);
1894 EXPECT_EQ(2u, str.GetLength());
1895 stream.str("");
1896 stream << str;
1897 EXPECT_EQ(2u, stream.tellp());
1898
1899 // Writing a ByteString with nulls but specifying its length treats it as
1900 // a C++-style string.
1901 // SAFETY: required for testing, manual length calculation based on above.
1902 str = UNSAFE_BUFFERS(ByteString(stringWithNulls, 4));
1903 EXPECT_EQ(4u, str.GetLength());
1904 stream.str("");
1905 stream << str;
1906 EXPECT_EQ(4u, stream.tellp());
1907
1908 // << operators can be chained.
1909 ByteString str1("abc");
1910 ByteString str2("def");
1911 stream.str("");
1912 stream << str1 << str2;
1913 EXPECT_EQ("abcdef", stream.str());
1914}
1915
1916TEST(ByteStringView, OStreamOverload) {
1917 // Basic case, empty string
1918 {
1919 std::ostringstream stream;
1920 ByteStringView str;
1921 stream << str;
1922 EXPECT_EQ("", stream.str());
1923 }
1924
1925 // Basic case, non-empty string
1926 {
1927 std::ostringstream stream;
1928 ByteStringView str("def");
1929 stream << "abc" << str << "ghi";
1930 EXPECT_EQ("abcdefghi", stream.str());
1931 }
1932
1933 // Changing the ByteStringView does not change the stream it was written to.
1934 {
1935 std::ostringstream stream;
1936 ByteStringView str("abc");
1937 stream << str;
1938 str = "123";
1939 EXPECT_EQ("abc", stream.str());
1940 }
1941
1942 // Writing it again to the stream will use the latest value.
1943 {
1944 std::ostringstream stream;
1945 ByteStringView str("abc");
1946 stream << str;
1947 stream.str("");
1948 str = "123";
1949 stream << str;
1950 EXPECT_EQ("123", stream.str());
1951 }
1952
1953 // Writing a ByteStringView with nulls and no specified length treats it as
1954 // a C-style null-terminated string.
1955 {
1956 std::ostringstream stream;
1957 char stringWithNulls[]{'x', 'y', '\0', 'z'};
1958 ByteStringView str(stringWithNulls);
1959 EXPECT_EQ(2u, str.GetLength());
1960 stream << str;
1961 EXPECT_EQ(2u, stream.tellp());
1962 str = "";
1963 }
1964
1965 // Writing a ByteStringView with nulls but specifying its length treats it as
1966 // a C++-style string.
1967 {
1968 std::ostringstream stream;
1969 char stringWithNulls[] = {'x', 'y', '\0', 'z'};
1970 // SAFETY: known array above.
1971 auto str = UNSAFE_BUFFERS(ByteStringView(stringWithNulls, 4));
1972 EXPECT_EQ(4u, str.GetLength());
1973 stream << str;
1974 EXPECT_EQ(4u, stream.tellp());
1975 str = "";
1976 }
1977
1978 // << operators can be chained.
1979 {
1980 std::ostringstream stream;
1981 ByteStringView str1("abc");
1982 ByteStringView str2("def");
1983 stream << str1 << str2;
1984 EXPECT_EQ("abcdef", stream.str());
1985 }
1986}
1987
1988TEST(ByteString, FormatInteger) {
1989 // Base case of 0.
1990 EXPECT_EQ("0", ByteString::FormatInteger(0));
1991
1992 // Positive ordinary number.
1993 EXPECT_EQ("123456", ByteString::FormatInteger(123456));
1994
1995 // Negative ordinary number.
1996 EXPECT_EQ("-123456", ByteString::FormatInteger(-123456));
1997
1998 // int limits.
1999 EXPECT_EQ("2147483647", ByteString::FormatInteger(INT_MAX));
2000 EXPECT_EQ("-2147483648", ByteString::FormatInteger(INT_MIN));
2001}
2002
2003TEST(ByteString, FX_HashCode_Ascii) {
2004 EXPECT_EQ(0u, FX_HashCode_GetA(""));
2005 EXPECT_EQ(65u, FX_HashCode_GetA("A"));
2006 EXPECT_EQ(97u, FX_HashCode_GetLoweredA("A"));
2007 EXPECT_EQ(31 * 65u + 66u, FX_HashCode_GetA("AB"));
2008 EXPECT_EQ(31u * 65u + 255u, FX_HashCode_GetA("A\xff"));
2009 EXPECT_EQ(31u * 97u + 255u, FX_HashCode_GetLoweredA("A\xff"));
2010}
2011
2012TEST(ByteString, FX_HashCode_Wide) {
2013 EXPECT_EQ(0u, FX_HashCode_GetAsIfW(""));
2014 EXPECT_EQ(65u, FX_HashCode_GetAsIfW("A"));
2015 EXPECT_EQ(97u, FX_HashCode_GetLoweredAsIfW("A"));
2016 EXPECT_EQ(1313u * 65u + 66u, FX_HashCode_GetAsIfW("AB"));
2017 EXPECT_EQ(1313u * 65u + 255u, FX_HashCode_GetAsIfW("A\xff"));
2018 EXPECT_EQ(1313u * 97u + 255u, FX_HashCode_GetLoweredAsIfW("A\xff"));
2019}
2020
2021} // namespace fxcrt
fxcrt::ByteString::ByteString
ByteString(const char *ptr)
Definition bytestring.cpp:103
fxcrt::ByteString::EqualNoCase
bool EqualNoCase(ByteStringView str) const
Definition bytestring.cpp:281
fxcrt::ByteString::Format
static ByteString Format(const char *pFormat,...)
Definition bytestring.cpp:79
fxcrt::ByteString::ReferenceCountForTesting
intptr_t ReferenceCountForTesting() const
Definition bytestring.cpp:302
fxcrt::ByteString::FormatInteger
static ByteString FormatInteger(int i)
Definition bytestring.cpp:45
fxcrt::ByteString::operator==
bool operator==(const ByteString &other) const
Definition bytestring.cpp:234
fxcrt::ByteString::operator==
bool operator==(const char *ptr) const
Definition bytestring.cpp:208
fxcrt::ByteString::operator+=
ByteString & operator+=(const char *str)
Definition bytestring.cpp:182
fxcrt::ByteString::operator!=
bool operator!=(const ByteString &other) const
Definition bytestring.h:67
fxcrt::ByteString::operator=
ByteString & operator=(const char *str)
Definition bytestring.cpp:150
fxcrt::ByteString::operator=
ByteString & operator=(const ByteString &that)
Definition bytestring.cpp:168
fxcrt::ByteString::operator=
ByteString & operator=(ByteString &&that) noexcept
Definition bytestring.cpp:175
fxcrt::ByteString::operator<
bool operator<(const ByteString &other) const
Definition bytestring.cpp:268
fxcrt::ByteString::operator!=
bool operator!=(const char *ptr) const
Definition bytestring.h:65
fxcrt::ByteString::ByteString
ByteString(const ByteString &other)=default
fxcrt::ByteString::operator<
bool operator<(const char *ptr) const
Definition bytestring.cpp:249
UNSAFE_BUFFERS
#define UNSAFE_BUFFERS(...)
Definition compiler_specific.h:95
FXBSTR_ID
constexpr uint32_t FXBSTR_ID(uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4)
Definition fx_string.h:19
fxcrt::operator==
bool operator==(const char *lhs, const ByteString &rhs)
Definition bytestring.h:109
fxcrt::TEST
TEST(ByteStringView, Null)
Definition bytestring_unittest.cpp:1170
fxcrt::operator+
ByteString operator+(const ByteString &str1, const char *str2)
Definition bytestring.h:155
fxcrt::TEST
TEST(ByteString, ElementAccess)
Definition bytestring_unittest.cpp:23
fxcrt::operator+
ByteString operator+(const char *str1, const ByteString &str2)
Definition bytestring.h:158
fxcrt::ByteStringView
StringViewTemplate< char > ByteStringView
Definition string_view_template.h:320
fxcrt::operator!=
bool operator!=(const char *lhs, const ByteString &rhs)
Definition bytestring.h:115
fxcrt::operator<
bool operator<(const char *lhs, const ByteString &rhs)
Definition bytestring.h:121
fxcrt::TEST
TEST(CFX_BytrString, EqualNoCase)
Definition bytestring_unittest.cpp:1853