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/fx_string.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "third_party/base/containers/contains.h"
18 #include "third_party/base/containers/span.h"
19
20 namespace fxcrt {
21
TEST(ByteString,ElementAccess)22 TEST(ByteString, ElementAccess) {
23 const ByteString abc("abc");
24 EXPECT_EQ('a', abc[0]);
25 EXPECT_EQ('b', abc[1]);
26 EXPECT_EQ('c', abc[2]);
27 #ifndef NDEBUG
28 EXPECT_DEATH({ abc[3]; }, ".*");
29 #endif
30
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));
34
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));
38
39 ByteString mutable_abc = abc;
40 EXPECT_EQ(abc.c_str(), mutable_abc.c_str());
41 EXPECT_EQ('a', mutable_abc[0]);
42 EXPECT_EQ('b', mutable_abc[1]);
43 EXPECT_EQ('c', mutable_abc[2]);
44 EXPECT_EQ(abc.c_str(), mutable_abc.c_str());
45 EXPECT_EQ("abc", abc);
46
47 const char* c_str = abc.c_str();
48 mutable_abc.SetAt(0, 'd');
49 EXPECT_EQ(c_str, abc.c_str());
50 EXPECT_NE(c_str, mutable_abc.c_str());
51 EXPECT_EQ("abc", abc);
52 EXPECT_EQ("dbc", mutable_abc);
53
54 mutable_abc.SetAt(1, 'e');
55 EXPECT_EQ("abc", abc);
56 EXPECT_EQ("dec", mutable_abc);
57
58 mutable_abc.SetAt(2, 'f');
59 EXPECT_EQ("abc", abc);
60 EXPECT_EQ("def", mutable_abc);
61 #ifndef NDEBUG
62 EXPECT_DEATH({ mutable_abc.SetAt(3, 'g'); }, ".*");
63 EXPECT_EQ("abc", abc);
64 #endif
65 }
66
TEST(ByteString,Construct)67 TEST(ByteString, Construct) {
68 {
69 // Copy-construct.
70 ByteString string1("abc");
71 ByteString string2(string1);
72 EXPECT_EQ("abc", string1);
73 EXPECT_EQ("abc", string2);
74 EXPECT_EQ(2, string1.ReferenceCountForTesting());
75 EXPECT_EQ(2, string2.ReferenceCountForTesting());
76 }
77 {
78 // Move-construct.
79 ByteString string1("abc");
80 ByteString string2(std::move(string1));
81 EXPECT_TRUE(string1.IsEmpty());
82 EXPECT_EQ("abc", string2);
83 EXPECT_EQ(0, string1.ReferenceCountForTesting());
84 EXPECT_EQ(1, string2.ReferenceCountForTesting());
85 }
86 }
87
TEST(ByteString,Assign)88 TEST(ByteString, Assign) {
89 {
90 // Copy-assign.
91 ByteString string1;
92 EXPECT_EQ(0, string1.ReferenceCountForTesting());
93 {
94 ByteString string2("abc");
95 EXPECT_EQ(1, string2.ReferenceCountForTesting());
96
97 string1 = string2;
98 EXPECT_EQ(2, string1.ReferenceCountForTesting());
99 EXPECT_EQ(2, string2.ReferenceCountForTesting());
100 }
101 EXPECT_EQ(1, string1.ReferenceCountForTesting());
102 }
103 {
104 // Move-assign.
105 ByteString string1;
106 EXPECT_EQ(0, string1.ReferenceCountForTesting());
107 {
108 ByteString string2("abc");
109 EXPECT_EQ(1, string2.ReferenceCountForTesting());
110
111 string1 = std::move(string2);
112 EXPECT_EQ("abc", string1);
113 EXPECT_TRUE(string2.IsEmpty());
114 EXPECT_EQ(1, string1.ReferenceCountForTesting());
115 EXPECT_EQ(0, string2.ReferenceCountForTesting());
116 }
117 EXPECT_EQ(1, string1.ReferenceCountForTesting());
118 }
119 {
120 // From char*.
121 ByteString string1 = "abc";
122 EXPECT_EQ("abc", string1);
123 string1 = nullptr;
124 EXPECT_TRUE(string1.IsEmpty());
125 string1 = "def";
126 EXPECT_EQ("def", string1);
127 string1 = "";
128 EXPECT_TRUE(string1.IsEmpty());
129 }
130 {
131 // From ByteStringView.
132 ByteString string1(ByteStringView("abc"));
133 EXPECT_EQ("abc", string1);
134 string1 = ByteStringView("");
135 EXPECT_TRUE(string1.IsEmpty());
136 string1 = ByteStringView("def");
137 EXPECT_EQ("def", string1);
138 }
139 }
140
TEST(ByteString,OperatorLT)141 TEST(ByteString, OperatorLT) {
142 ByteString empty;
143 ByteString a("a");
144 ByteString abc("abc");
145 ByteString def("def");
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";
155
156 EXPECT_FALSE(empty < empty);
157 EXPECT_FALSE(a < a);
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);
174
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);
185
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);
196
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);
207
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);
216
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);
225
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);
234
235 EXPECT_TRUE(v_empty < a);
236 EXPECT_TRUE(v_empty < c_a);
237
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"));
247 }
248
TEST(ByteString,OperatorEQ)249 TEST(ByteString, OperatorEQ) {
250 ByteString null_string;
251 EXPECT_TRUE(null_string == null_string);
252
253 ByteString empty_string("");
254 EXPECT_TRUE(empty_string == empty_string);
255 EXPECT_TRUE(empty_string == null_string);
256 EXPECT_TRUE(null_string == empty_string);
257
258 ByteString deleted_string("hello");
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);
265
266 ByteString byte_string("hello");
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);
274
275 ByteString byte_string_same1("hello");
276 EXPECT_TRUE(byte_string == byte_string_same1);
277 EXPECT_TRUE(byte_string_same1 == byte_string);
278
279 ByteString byte_string_same2(byte_string);
280 EXPECT_TRUE(byte_string == byte_string_same2);
281 EXPECT_TRUE(byte_string_same2 == byte_string);
282
283 ByteString byte_string1("he");
284 ByteString byte_string2("hellp");
285 ByteString byte_string3("hellod");
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);
292
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);
307
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);
311
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);
321
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);
336
337 const char* const c_string_same1 = "hello";
338 EXPECT_TRUE(byte_string == c_string_same1);
339 EXPECT_TRUE(c_string_same1 == byte_string);
340
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);
350 }
351
TEST(ByteString,OperatorNE)352 TEST(ByteString, OperatorNE) {
353 ByteString null_string;
354 EXPECT_FALSE(null_string != null_string);
355
356 ByteString empty_string("");
357 EXPECT_FALSE(empty_string != empty_string);
358 EXPECT_FALSE(empty_string != null_string);
359 EXPECT_FALSE(null_string != empty_string);
360
361 ByteString deleted_string("hello");
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);
370
371 ByteString byte_string("hello");
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);
379
380 ByteString byte_string_same1("hello");
381 EXPECT_FALSE(byte_string != byte_string_same1);
382 EXPECT_FALSE(byte_string_same1 != byte_string);
383
384 ByteString byte_string_same2(byte_string);
385 EXPECT_FALSE(byte_string != byte_string_same2);
386 EXPECT_FALSE(byte_string_same2 != byte_string);
387
388 ByteString byte_string1("he");
389 ByteString byte_string2("hellp");
390 ByteString byte_string3("hellod");
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);
397
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);
408
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);
412
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);
422
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);
437
438 const char* const c_string_same1 = "hello";
439 EXPECT_FALSE(byte_string != c_string_same1);
440 EXPECT_FALSE(c_string_same1 != byte_string);
441
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);
451 }
452
TEST(ByteString,OperatorPlus)453 TEST(ByteString, OperatorPlus) {
454 EXPECT_EQ("I like dogs", "I like " + ByteString("dogs"));
455 EXPECT_EQ("Dogs like me", ByteString("Dogs") + " like me");
456 EXPECT_EQ("Oh no, error number 42",
457 "Oh no, error number " + ByteString::Format("%d", 42));
458
459 {
460 // Make sure operator+= and Concat() increases string memory allocation
461 // geometrically.
462 int allocations = 0;
463 ByteString str("ABCDEFGHIJKLMN");
464 const char* buffer = str.c_str();
465 for (size_t i = 0; i < 10000; ++i) {
466 str += "!";
467 const char* new_buffer = str.c_str();
468 if (new_buffer != buffer) {
469 buffer = new_buffer;
470 ++allocations;
471 }
472 }
473 EXPECT_LT(allocations, 25);
474 EXPECT_GT(allocations, 10);
475 }
476 }
477
TEST(ByteString,Concat)478 TEST(ByteString, Concat) {
479 ByteString fred;
480 fred.Concat("FRED", 4);
481 EXPECT_EQ("FRED", fred);
482
483 fred.Concat("DY", 2);
484 EXPECT_EQ("FREDDY", fred);
485
486 fred.Delete(3, 3);
487 EXPECT_EQ("FRE", fred);
488
489 fred.Concat("D", 1);
490 EXPECT_EQ("FRED", fred);
491
492 ByteString copy = fred;
493 fred.Concat("DY", 2);
494 EXPECT_EQ("FREDDY", fred);
495 EXPECT_EQ("FRED", copy);
496 }
497
TEST(ByteString,Remove)498 TEST(ByteString, Remove) {
499 ByteString freed("FREED");
500 freed.Remove('E');
501 EXPECT_EQ("FRD", freed);
502 freed.Remove('F');
503 EXPECT_EQ("RD", freed);
504 freed.Remove('D');
505 EXPECT_EQ("R", freed);
506 freed.Remove('X');
507 EXPECT_EQ("R", freed);
508 freed.Remove('R');
509 EXPECT_EQ("", freed);
510
511 ByteString empty;
512 empty.Remove('X');
513 EXPECT_EQ("", empty);
514 }
515
TEST(ByteString,RemoveCopies)516 TEST(ByteString, RemoveCopies) {
517 ByteString freed("FREED");
518 const char* old_buffer = freed.c_str();
519
520 // No change with single reference - no copy.
521 freed.Remove('Q');
522 EXPECT_EQ("FREED", freed);
523 EXPECT_EQ(old_buffer, freed.c_str());
524
525 // Change with single reference - no copy.
526 freed.Remove('E');
527 EXPECT_EQ("FRD", freed);
528 EXPECT_EQ(old_buffer, freed.c_str());
529
530 // No change with multiple references - no copy.
531 ByteString shared(freed);
532 freed.Remove('Q');
533 EXPECT_EQ("FRD", freed);
534 EXPECT_EQ(old_buffer, freed.c_str());
535 EXPECT_EQ(old_buffer, shared.c_str());
536
537 // Change with multiple references -- must copy.
538 freed.Remove('D');
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());
543 }
544
TEST(ByteString,Replace)545 TEST(ByteString, Replace) {
546 ByteString empty;
547 empty.Replace("", "CLAMS");
548 empty.Replace("xx", "CLAMS");
549 EXPECT_EQ("", empty);
550
551 ByteString fred("FRED");
552 fred.Replace("", "");
553 EXPECT_EQ("FRED", fred);
554 fred.Replace("", "CLAMS");
555 EXPECT_EQ("FRED", fred);
556 fred.Replace("FR", "BL");
557 EXPECT_EQ("BLED", fred);
558 fred.Replace("D", "DDY");
559 EXPECT_EQ("BLEDDY", fred);
560 fred.Replace("LEDD", "");
561 EXPECT_EQ("BY", fred);
562 fred.Replace("X", "CLAMS");
563 EXPECT_EQ("BY", fred);
564 fred.Replace("BY", "HI");
565 EXPECT_EQ("HI", fred);
566 fred.Replace("I", "IHIHI");
567 EXPECT_EQ("HIHIHI", fred);
568 fred.Replace("HI", "HO");
569 EXPECT_EQ("HOHOHO", fred);
570 fred.Replace("HO", "");
571 EXPECT_EQ("", fred);
572
573 ByteString five_xs("xxxxx");
574 five_xs.Replace("xx", "xxx");
575 EXPECT_EQ("xxxxxxx", five_xs);
576
577 ByteString five_ys("yyyyy");
578 five_ys.Replace("yy", "y");
579 EXPECT_EQ("yyy", five_ys);
580 }
581
TEST(ByteString,Insert)582 TEST(ByteString, Insert) {
583 ByteString fred("FRED");
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);
594 {
595 ByteString empty;
596 EXPECT_EQ(1u, empty.Insert(0, 'X'));
597 EXPECT_EQ("X", empty);
598 }
599 {
600 ByteString empty;
601 EXPECT_EQ(0u, empty.Insert(5, 'X'));
602 EXPECT_NE("X", empty);
603 }
604 }
605
TEST(ByteString,InsertAtFrontAndInsertAtBack)606 TEST(ByteString, InsertAtFrontAndInsertAtBack) {
607 {
608 ByteString 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);
617 }
618 {
619 ByteString 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);
628 }
629 {
630 ByteString 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);
639 }
640 }
641
TEST(ByteString,Delete)642 TEST(ByteString, Delete) {
643 ByteString fred("FRED");
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));
651 EXPECT_EQ("", fred);
652 EXPECT_EQ(0u, fred.Delete(0));
653 EXPECT_EQ("", fred);
654
655 ByteString empty;
656 EXPECT_EQ(0u, empty.Delete(0));
657 EXPECT_EQ("", empty);
658 EXPECT_EQ(0u, empty.Delete(1));
659 EXPECT_EQ("", empty);
660 }
661
TEST(ByteString,OneArgSubstr)662 TEST(ByteString, OneArgSubstr) {
663 ByteString fred("FRED");
664 EXPECT_EQ("FRED", fred.Substr(0));
665 EXPECT_EQ("RED", fred.Substr(1));
666 EXPECT_EQ("ED", fred.Substr(2));
667 EXPECT_EQ("D", fred.Substr(3));
668 EXPECT_EQ("", fred.Substr(4));
669
670 ByteString empty;
671 EXPECT_EQ("", empty.Substr(0));
672 EXPECT_EQ("", empty.Substr(1));
673 }
674
TEST(ByteString,TwoArgSubstr)675 TEST(ByteString, TwoArgSubstr) {
676 ByteString fred("FRED");
677 EXPECT_EQ("", fred.Substr(0, 0));
678 EXPECT_EQ("", fred.Substr(3, 0));
679 EXPECT_EQ("FRED", fred.Substr(0, 4));
680 EXPECT_EQ("RED", fred.Substr(1, 3));
681 EXPECT_EQ("ED", fred.Substr(2, 2));
682 EXPECT_EQ("D", fred.Substr(3, 1));
683 EXPECT_EQ("F", fred.Substr(0, 1));
684 EXPECT_EQ("R", fred.Substr(1, 1));
685 EXPECT_EQ("E", fred.Substr(2, 1));
686 EXPECT_EQ("D", fred.Substr(3, 1));
687 EXPECT_EQ("FR", fred.Substr(0, 2));
688 EXPECT_EQ("FRED", fred.Substr(0, 4));
689 EXPECT_EQ("", fred.Substr(0, 10));
690
691 EXPECT_EQ("RED", fred.Substr(1, 3));
692 EXPECT_EQ("", fred.Substr(4, 1));
693
694 ByteString empty;
695 EXPECT_EQ("", empty.Substr(0, 0));
696 }
697
TEST(ByteString,First)698 TEST(ByteString, First) {
699 ByteString fred("FRED");
700 EXPECT_EQ("", fred.First(0));
701 EXPECT_EQ("F", fred.First(1));
702 EXPECT_EQ("FR", fred.First(2));
703 EXPECT_EQ("FRE", fred.First(3));
704 EXPECT_EQ("FRED", fred.First(4));
705
706 EXPECT_EQ("", fred.First(5));
707
708 ByteString empty;
709 EXPECT_EQ("", empty.First(0));
710 EXPECT_EQ("", empty.First(1));
711 }
712
TEST(ByteString,Last)713 TEST(ByteString, Last) {
714 ByteString fred("FRED");
715 EXPECT_EQ("", fred.Last(0));
716 EXPECT_EQ("D", fred.Last(1));
717 EXPECT_EQ("ED", fred.Last(2));
718 EXPECT_EQ("RED", fred.Last(3));
719 EXPECT_EQ("FRED", fred.Last(4));
720
721 EXPECT_EQ("", fred.Last(5));
722
723 ByteString empty;
724 EXPECT_EQ("", empty.Last(0));
725 EXPECT_EQ("", empty.Last(1));
726 }
727
TEST(ByteString,Find)728 TEST(ByteString, Find) {
729 ByteString null_string;
730 EXPECT_FALSE(null_string.Find('a').has_value());
731 EXPECT_FALSE(null_string.Find('\0').has_value());
732
733 ByteString empty_string("");
734 EXPECT_FALSE(empty_string.Find('a').has_value());
735 EXPECT_FALSE(empty_string.Find('\0').has_value());
736
737 ByteString single_string("a");
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());
743
744 ByteString longer_string("abccc");
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());
756
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());
767
768 ByteString hibyte_string(
769 "ab\x8c"
770 "def");
771 result = hibyte_string.Find('\x8c');
772 ASSERT_TRUE(result.has_value());
773 EXPECT_EQ(2u, result.value());
774 }
775
TEST(ByteString,ReverseFind)776 TEST(ByteString, ReverseFind) {
777 ByteString null_string;
778 EXPECT_FALSE(null_string.ReverseFind('a').has_value());
779 EXPECT_FALSE(null_string.ReverseFind('\0').has_value());
780
781 ByteString empty_string("");
782 EXPECT_FALSE(empty_string.ReverseFind('a').has_value());
783 EXPECT_FALSE(empty_string.ReverseFind('\0').has_value());
784
785 ByteString single_string("a");
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());
791
792 ByteString longer_string("abccc");
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());
800
801 ByteString hibyte_string(
802 "ab\x8c"
803 "def");
804 result = hibyte_string.ReverseFind('\x8c');
805 ASSERT_TRUE(result.has_value());
806 EXPECT_EQ(2u, result.value());
807 }
808
TEST(ByteString,UpperLower)809 TEST(ByteString, UpperLower) {
810 ByteString fred("F-Re.42D");
811 fred.MakeLower();
812 EXPECT_EQ("f-re.42d", fred);
813 fred.MakeUpper();
814 EXPECT_EQ("F-RE.42D", fred);
815
816 ByteString empty;
817 empty.MakeLower();
818 EXPECT_EQ("", empty);
819 empty.MakeUpper();
820 EXPECT_EQ("", empty);
821
822 ByteString empty_with_buffer("x");
823 empty_with_buffer.Delete(0);
824
825 ByteString additional_empty_with_buffer_ref = empty_with_buffer;
826 additional_empty_with_buffer_ref.MakeLower();
827 EXPECT_EQ("", additional_empty_with_buffer_ref);
828
829 additional_empty_with_buffer_ref = empty_with_buffer;
830 additional_empty_with_buffer_ref.MakeUpper();
831 EXPECT_EQ("", additional_empty_with_buffer_ref);
832 }
833
TEST(ByteString,Trim)834 TEST(ByteString, Trim) {
835 ByteString fred(" FRED ");
836 fred.Trim();
837 EXPECT_EQ("FRED", fred);
838 fred.Trim('E');
839 EXPECT_EQ("FRED", fred);
840 fred.Trim('F');
841 EXPECT_EQ("RED", fred);
842 fred.Trim("ERP");
843 EXPECT_EQ("D", fred);
844
845 ByteString blank(" ");
846 blank.Trim("ERP");
847 EXPECT_EQ(" ", blank);
848 blank.Trim('E');
849 EXPECT_EQ(" ", blank);
850 blank.Trim();
851 EXPECT_EQ("", blank);
852
853 ByteString empty;
854 empty.Trim("ERP");
855 EXPECT_EQ("", empty);
856 empty.Trim('E');
857 EXPECT_EQ("", empty);
858 empty.Trim();
859 EXPECT_EQ("", empty);
860
861 ByteString abc(" ABCCBA ");
862 abc.Trim("A");
863 EXPECT_EQ(" ABCCBA ", abc);
864 abc.Trim(" A");
865 EXPECT_EQ("BCCB", abc);
866 }
867
TEST(ByteString,TrimLeft)868 TEST(ByteString, TrimLeft) {
869 ByteString fred(" FRED ");
870 fred.TrimLeft();
871 EXPECT_EQ("FRED ", fred);
872 fred.TrimLeft('E');
873 EXPECT_EQ("FRED ", fred);
874 fred.TrimLeft('F');
875 EXPECT_EQ("RED ", fred);
876 fred.TrimLeft("ERP");
877 EXPECT_EQ("D ", fred);
878
879 ByteString blank(" ");
880 blank.TrimLeft("ERP");
881 EXPECT_EQ(" ", blank);
882 blank.TrimLeft('E');
883 EXPECT_EQ(" ", blank);
884 blank.TrimLeft();
885 EXPECT_EQ("", blank);
886
887 ByteString empty;
888 empty.TrimLeft("ERP");
889 EXPECT_EQ("", empty);
890 empty.TrimLeft('E');
891 EXPECT_EQ("", empty);
892 empty.TrimLeft();
893 EXPECT_EQ("", empty);
894 }
895
TEST(ByteString,TrimLeftCopies)896 TEST(ByteString, TrimLeftCopies) {
897 {
898 // With a single reference, no copy takes place.
899 ByteString fred(" FRED ");
900 const char* old_buffer = fred.c_str();
901 fred.TrimLeft();
902 EXPECT_EQ("FRED ", fred);
903 EXPECT_EQ(old_buffer, fred.c_str());
904 }
905 {
906 // With multiple references, we must copy.
907 ByteString fred(" FRED ");
908 ByteString other_fred = fred;
909 const char* old_buffer = fred.c_str();
910 fred.TrimLeft();
911 EXPECT_EQ("FRED ", fred);
912 EXPECT_EQ(" FRED ", other_fred);
913 EXPECT_NE(old_buffer, fred.c_str());
914 }
915 {
916 // With multiple references, but no modifications, no copy.
917 ByteString fred("FRED");
918 ByteString other_fred = fred;
919 const char* old_buffer = fred.c_str();
920 fred.TrimLeft();
921 EXPECT_EQ("FRED", fred);
922 EXPECT_EQ("FRED", other_fred);
923 EXPECT_EQ(old_buffer, fred.c_str());
924 }
925 }
926
TEST(ByteString,TrimRight)927 TEST(ByteString, TrimRight) {
928 ByteString fred(" FRED ");
929 fred.TrimRight();
930 EXPECT_EQ(" FRED", fred);
931 fred.TrimRight('E');
932 EXPECT_EQ(" FRED", fred);
933 fred.TrimRight('D');
934 EXPECT_EQ(" FRE", fred);
935 fred.TrimRight("ERP");
936 EXPECT_EQ(" F", fred);
937
938 ByteString blank(" ");
939 blank.TrimRight("ERP");
940 EXPECT_EQ(" ", blank);
941 blank.TrimRight('E');
942 EXPECT_EQ(" ", blank);
943 blank.TrimRight();
944 EXPECT_EQ("", blank);
945
946 ByteString empty;
947 empty.TrimRight("ERP");
948 EXPECT_EQ("", empty);
949 empty.TrimRight('E');
950 EXPECT_EQ("", empty);
951 empty.TrimRight();
952 EXPECT_EQ("", empty);
953 }
954
TEST(ByteString,TrimRightCopies)955 TEST(ByteString, TrimRightCopies) {
956 {
957 // With a single reference, no copy takes place.
958 ByteString fred(" FRED ");
959 const char* old_buffer = fred.c_str();
960 fred.TrimRight();
961 EXPECT_EQ(" FRED", fred);
962 EXPECT_EQ(old_buffer, fred.c_str());
963 }
964 {
965 // With multiple references, we must copy.
966 ByteString fred(" FRED ");
967 ByteString other_fred = fred;
968 const char* old_buffer = fred.c_str();
969 fred.TrimRight();
970 EXPECT_EQ(" FRED", fred);
971 EXPECT_EQ(" FRED ", other_fred);
972 EXPECT_NE(old_buffer, fred.c_str());
973 }
974 {
975 // With multiple references, but no modifications, no copy.
976 ByteString fred("FRED");
977 ByteString other_fred = fred;
978 const char* old_buffer = fred.c_str();
979 fred.TrimRight();
980 EXPECT_EQ("FRED", fred);
981 EXPECT_EQ("FRED", other_fred);
982 EXPECT_EQ(old_buffer, fred.c_str());
983 }
984 }
985
TEST(ByteString,Reserve)986 TEST(ByteString, Reserve) {
987 {
988 ByteString str;
989 str.Reserve(6);
990 const char* old_buffer = str.c_str();
991 str += "ABCDEF";
992 EXPECT_EQ(old_buffer, str.c_str());
993 str += "Blah Blah Blah Blah Blah Blah";
994 EXPECT_NE(old_buffer, str.c_str());
995 }
996 {
997 ByteString str("A");
998 str.Reserve(6);
999 const char* old_buffer = str.c_str();
1000 str += "BCDEF";
1001 EXPECT_EQ(old_buffer, str.c_str());
1002 str += "Blah Blah Blah Blah Blah Blah";
1003 EXPECT_NE(old_buffer, str.c_str());
1004 }
1005 }
1006
TEST(ByteString,GetBuffer)1007 TEST(ByteString, GetBuffer) {
1008 ByteString str1;
1009 {
1010 pdfium::span<char> buffer = str1.GetBuffer(12);
1011 // NOLINTNEXTLINE(runtime/printf)
1012 strcpy(buffer.data(), "clams");
1013 }
1014 str1.ReleaseBuffer(str1.GetStringLength());
1015 EXPECT_EQ("clams", str1);
1016
1017 ByteString str2("cl");
1018 {
1019 pdfium::span<char> buffer = str2.GetBuffer(12);
1020 // NOLINTNEXTLINE(runtime/printf)
1021 strcpy(&buffer[2], "ams");
1022 }
1023 str2.ReleaseBuffer(str2.GetStringLength());
1024 EXPECT_EQ("clams", str2);
1025 }
1026
TEST(ByteString,ReleaseBuffer)1027 TEST(ByteString, ReleaseBuffer) {
1028 {
1029 ByteString str;
1030 str.Reserve(12);
1031 str += "clams";
1032 const char* old_buffer = str.c_str();
1033 str.ReleaseBuffer(4);
1034 EXPECT_EQ(old_buffer, str.c_str());
1035 EXPECT_EQ("clam", str);
1036 }
1037 {
1038 ByteString str("c");
1039 str.Reserve(12);
1040 str += "lams";
1041 const char* old_buffer = str.c_str();
1042 str.ReleaseBuffer(4);
1043 EXPECT_EQ(old_buffer, str.c_str());
1044 EXPECT_EQ("clam", str);
1045 }
1046 {
1047 ByteString str;
1048 str.Reserve(200);
1049 str += "clams";
1050 const char* old_buffer = str.c_str();
1051 str.ReleaseBuffer(4);
1052 EXPECT_NE(old_buffer, str.c_str());
1053 EXPECT_EQ("clam", str);
1054 }
1055 {
1056 ByteString str("c");
1057 str.Reserve(200);
1058 str += "lams";
1059 const char* old_buffer = str.c_str();
1060 str.ReleaseBuffer(4);
1061 EXPECT_NE(old_buffer, str.c_str());
1062 EXPECT_EQ("clam", str);
1063 }
1064 }
1065
TEST(ByteString,EmptyReverseIterator)1066 TEST(ByteString, EmptyReverseIterator) {
1067 ByteString empty;
1068 auto iter = empty.rbegin();
1069 EXPECT_TRUE(iter == empty.rend());
1070 EXPECT_FALSE(iter != empty.rend());
1071 EXPECT_FALSE(iter < empty.rend());
1072 }
1073
TEST(ByteString,OneCharReverseIterator)1074 TEST(ByteString, OneCharReverseIterator) {
1075 ByteString one_str("a");
1076 auto iter = one_str.rbegin();
1077 EXPECT_FALSE(iter == one_str.rend());
1078 EXPECT_TRUE(iter != one_str.rend());
1079 EXPECT_TRUE(iter < one_str.rend());
1080
1081 char ch = *iter++;
1082 EXPECT_EQ('a', ch);
1083 EXPECT_TRUE(iter == one_str.rend());
1084 EXPECT_FALSE(iter != one_str.rend());
1085 EXPECT_FALSE(iter < one_str.rend());
1086 }
1087
TEST(ByteString,MultiCharReverseIterator)1088 TEST(ByteString, MultiCharReverseIterator) {
1089 ByteString multi_str("abcd");
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());
1094
1095 char ch = *iter++;
1096 EXPECT_EQ('d', ch);
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());
1101
1102 ch = *(++iter);
1103 EXPECT_EQ('b', ch);
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());
1108
1109 ch = *iter++;
1110 EXPECT_EQ('b', ch);
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());
1115
1116 ch = *iter++;
1117 EXPECT_EQ('a', ch);
1118 EXPECT_EQ(iter, multi_str.rend());
1119 EXPECT_EQ(0, multi_str.rend() - iter);
1120 EXPECT_EQ(4, iter - multi_str.rbegin());
1121
1122 ch = *(--iter);
1123 EXPECT_EQ('a', ch);
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());
1128
1129 ch = *iter--;
1130 EXPECT_EQ('a', ch);
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());
1135
1136 ch = *iter--;
1137 EXPECT_EQ('b', ch);
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());
1142
1143 ch = *(--iter);
1144 EXPECT_EQ('d', ch);
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());
1149 }
1150
TEST(ByteStringView,Null)1151 TEST(ByteStringView, Null) {
1152 ByteStringView null_string;
1153 EXPECT_FALSE(null_string.raw_str());
1154 EXPECT_EQ(0u, null_string.GetLength());
1155 EXPECT_TRUE(null_string.IsEmpty());
1156
1157 ByteStringView another_null_string;
1158 EXPECT_EQ(null_string, another_null_string);
1159
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);
1165
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);
1171
1172 ByteStringView empty_string(""); // Pointer to NUL, not NULL pointer.
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);
1177
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);
1184
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);
1191
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);
1198
1199 ByteStringView non_null_string("a");
1200 EXPECT_NE(null_string, non_null_string);
1201 }
1202
TEST(ByteStringView,NotNull)1203 TEST(ByteStringView, NotNull) {
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", 4)));
1208 ByteStringView embedded_nul_string7("abc\0def", 7);
1209 ByteStringView illegal_string7("abcdef", 7);
1210
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());
1217
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);
1228
1229 ByteStringView copied_string3(string3);
1230 ByteStringView copied_alternate_string3(alternate_string3);
1231 ByteStringView copied_embedded_nul_string7(embedded_nul_string7);
1232
1233 EXPECT_EQ(string3, copied_string3);
1234 EXPECT_EQ(alternate_string3, copied_alternate_string3);
1235 EXPECT_EQ(embedded_nul_string7, copied_embedded_nul_string7);
1236
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");
1241
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);
1250 }
1251
TEST(ByteStringView,FromChar)1252 TEST(ByteStringView, FromChar) {
1253 ByteStringView null_string;
1254 ByteStringView lower_a_string("a");
1255
1256 // Must have lvalues that outlive the corresponding ByteStringC.
1257 char nul = '\0';
1258 char lower_a = 'a';
1259 ByteStringView nul_string_from_char(nul);
1260 ByteStringView lower_a_string_from_char(lower_a);
1261
1262 // Pointer to nul, not nullptr ptr, hence length 1 ...
1263 EXPECT_EQ(1u, nul_string_from_char.GetLength());
1264 EXPECT_NE(null_string, nul_string_from_char);
1265
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);
1269
1270 ByteStringView longer_string("ab");
1271 EXPECT_NE(longer_string, lower_a_string_from_char);
1272 }
1273
TEST(ByteStringView,FromVector)1274 TEST(ByteStringView, FromVector) {
1275 std::vector<uint8_t> null_vec;
1276 ByteStringView null_string(null_vec);
1277 EXPECT_EQ(0u, null_string.GetLength());
1278
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);
1283
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());
1290 }
1291
TEST(ByteStringView,GetID)1292 TEST(ByteStringView, GetID) {
1293 ByteStringView null_string;
1294 EXPECT_EQ(0u, null_string.GetID());
1295
1296 ByteStringView empty_string("");
1297 EXPECT_EQ(0u, empty_string.GetID());
1298
1299 ByteStringView short_string("ab");
1300 EXPECT_EQ(FXBSTR_ID('a', 'b', 0, 0), short_string.GetID());
1301
1302 ByteStringView longer_string("abcdef");
1303 EXPECT_EQ(FXBSTR_ID('a', 'b', 'c', 'd'), longer_string.GetID());
1304 }
1305
TEST(ByteStringView,Find)1306 TEST(ByteStringView, Find) {
1307 ByteStringView null_string;
1308 EXPECT_FALSE(null_string.Find('a').has_value());
1309 EXPECT_FALSE(null_string.Find('\0').has_value());
1310
1311 ByteStringView empty_string("");
1312 EXPECT_FALSE(empty_string.Find('a').has_value());
1313 EXPECT_FALSE(empty_string.Find('\0').has_value());
1314
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());
1321
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());
1331
1332 ByteStringView hibyte_string(
1333 "ab\x8c"
1334 "def");
1335 result = hibyte_string.Find('\x8c');
1336 ASSERT_TRUE(result.has_value());
1337 EXPECT_EQ(2u, result.value());
1338 }
1339
TEST(ByteStringView,OneArgSubstr)1340 TEST(ByteStringView, OneArgSubstr) {
1341 ByteStringView null_string;
1342 EXPECT_EQ(null_string, null_string.Substr(0));
1343 EXPECT_EQ(null_string, null_string.Substr(1));
1344
1345 ByteStringView empty_string("");
1346 EXPECT_EQ("", empty_string.Substr(0));
1347 EXPECT_EQ("", empty_string.Substr(1));
1348
1349 ByteStringView single_character("a");
1350 EXPECT_EQ(single_character, single_character.Substr(0));
1351 EXPECT_EQ("", single_character.Substr(1));
1352
1353 ByteStringView longer_string("abcdef");
1354 EXPECT_EQ(longer_string, longer_string.Substr(0));
1355 EXPECT_EQ("", longer_string.Substr(187));
1356
1357 ByteStringView trailing_substring("ef");
1358 EXPECT_EQ(trailing_substring, longer_string.Substr(4));
1359 }
1360
TEST(ByteStringView,TwoArgSubstr)1361 TEST(ByteStringView, TwoArgSubstr) {
1362 ByteStringView null_string;
1363 EXPECT_EQ(null_string, null_string.Substr(0, 1));
1364 EXPECT_EQ(null_string, null_string.Substr(1, 1));
1365
1366 ByteStringView empty_string("");
1367 EXPECT_EQ("", empty_string.Substr(0, 1));
1368 EXPECT_EQ("", empty_string.Substr(1, 1));
1369
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));
1375
1376 ByteStringView longer_string("abcdef");
1377 EXPECT_EQ(longer_string, longer_string.Substr(0, 6));
1378 EXPECT_EQ("", longer_string.Substr(0, 187));
1379
1380 ByteStringView leading_substring("ab");
1381 EXPECT_EQ(leading_substring, longer_string.Substr(0, 2));
1382
1383 ByteStringView middle_substring("bcde");
1384 EXPECT_EQ(middle_substring, longer_string.Substr(1, 4));
1385
1386 ByteStringView trailing_substring("ef");
1387 EXPECT_EQ(trailing_substring, longer_string.Substr(4, 2));
1388 EXPECT_EQ("", longer_string.Substr(4, 3));
1389 }
1390
TEST(ByteStringView,TrimmedRight)1391 TEST(ByteStringView, TrimmedRight) {
1392 ByteStringView fred("FRED");
1393 EXPECT_EQ("FRED", fred.TrimmedRight('E'));
1394 EXPECT_EQ("FRE", fred.TrimmedRight('D'));
1395 ByteStringView fredd("FREDD");
1396 EXPECT_EQ("FRE", fred.TrimmedRight('D'));
1397 }
1398
TEST(ByteStringView,ElementAccess)1399 TEST(ByteStringView, ElementAccess) {
1400 // ByteStringView includes the NUL terminator for non-empty strings.
1401 ByteStringView abc("abc");
1402 EXPECT_EQ('a', static_cast<char>(abc[0]));
1403 EXPECT_EQ('b', static_cast<char>(abc[1]));
1404 EXPECT_EQ('c', static_cast<char>(abc[2]));
1405 #ifndef NDEBUG
1406 EXPECT_DEATH({ abc[3]; }, ".*");
1407 #endif
1408 }
1409
TEST(ByteStringView,OperatorLT)1410 TEST(ByteStringView, OperatorLT) {
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";
1420
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);
1435
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);
1441
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);
1447
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);
1453
1454 EXPECT_TRUE(a < abc);
1455 EXPECT_FALSE(abc < a);
1456 EXPECT_TRUE(a < c_abc);
1457 EXPECT_FALSE(abc < c_a);
1458
1459 EXPECT_TRUE(a < def);
1460 EXPECT_FALSE(def < a);
1461 EXPECT_TRUE(a < c_def);
1462 EXPECT_FALSE(def < c_a);
1463
1464 EXPECT_TRUE(abc < def);
1465 EXPECT_FALSE(def < abc);
1466 EXPECT_TRUE(abc < c_def);
1467 EXPECT_FALSE(def < c_abc);
1468 }
1469
TEST(ByteStringView,OperatorEQ)1470 TEST(ByteStringView, OperatorEQ) {
1471 ByteStringView byte_string_c("hello");
1472 EXPECT_TRUE(byte_string_c == byte_string_c);
1473
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);
1477
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);
1481
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);
1491
1492 ByteString byte_string_same1("hello");
1493 EXPECT_TRUE(byte_string_c == byte_string_same1);
1494 EXPECT_TRUE(byte_string_same1 == byte_string_c);
1495
1496 ByteString byte_string1("he");
1497 ByteString byte_string2("hellp");
1498 ByteString byte_string3("hellod");
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);
1505
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);
1509
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);
1516
1517 EXPECT_FALSE(c_string1 == byte_string_c);
1518 EXPECT_FALSE(c_string2 == byte_string_c);
1519 EXPECT_FALSE(c_string3 == byte_string_c);
1520
1521 pdfium::span<const uint8_t> span5(
1522 pdfium::as_bytes(pdfium::make_span("hello", 5)));
1523 EXPECT_EQ(byte_string_c.raw_span(), span5);
1524 }
1525
TEST(ByteStringView,OperatorNE)1526 TEST(ByteStringView, OperatorNE) {
1527 ByteStringView byte_string_c("hello");
1528 EXPECT_FALSE(byte_string_c != byte_string_c);
1529
1530 ByteStringView byte_string_c_same1("hello");
1531 EXPECT_FALSE(byte_string_c != byte_string_c_same1);
1532 EXPECT_FALSE(byte_string_c_same1 != byte_string_c);
1533
1534 ByteStringView byte_string_c_same2(byte_string_c);
1535 EXPECT_FALSE(byte_string_c != byte_string_c_same2);
1536 EXPECT_FALSE(byte_string_c_same2 != byte_string_c);
1537
1538 ByteStringView byte_string_c1("he");
1539 ByteStringView byte_string_c2("hellp");
1540 ByteStringView byte_string_c3("hellod");
1541 EXPECT_TRUE(byte_string_c != byte_string_c1);
1542 EXPECT_TRUE(byte_string_c != byte_string_c2);
1543 EXPECT_TRUE(byte_string_c != byte_string_c3);
1544 EXPECT_TRUE(byte_string_c1 != byte_string_c);
1545 EXPECT_TRUE(byte_string_c2 != byte_string_c);
1546 EXPECT_TRUE(byte_string_c3 != byte_string_c);
1547
1548 ByteString byte_string_same1("hello");
1549 EXPECT_FALSE(byte_string_c != byte_string_same1);
1550 EXPECT_FALSE(byte_string_same1 != byte_string_c);
1551
1552 ByteString byte_string1("he");
1553 ByteString byte_string2("hellp");
1554 ByteString byte_string3("hellod");
1555 EXPECT_TRUE(byte_string_c != byte_string1);
1556 EXPECT_TRUE(byte_string_c != byte_string2);
1557 EXPECT_TRUE(byte_string_c != byte_string3);
1558 EXPECT_TRUE(byte_string1 != byte_string_c);
1559 EXPECT_TRUE(byte_string2 != byte_string_c);
1560 EXPECT_TRUE(byte_string3 != byte_string_c);
1561
1562 const char* const c_string_same1 = "hello";
1563 EXPECT_FALSE(byte_string_c != c_string_same1);
1564 EXPECT_FALSE(c_string_same1 != byte_string_c);
1565
1566 const char* const c_string1 = "he";
1567 const char* const c_string2 = "hellp";
1568 const char* const c_string3 = "hellod";
1569 EXPECT_TRUE(byte_string_c != c_string1);
1570 EXPECT_TRUE(byte_string_c != c_string2);
1571 EXPECT_TRUE(byte_string_c != c_string3);
1572
1573 EXPECT_TRUE(c_string1 != byte_string_c);
1574 EXPECT_TRUE(c_string2 != byte_string_c);
1575 EXPECT_TRUE(c_string3 != byte_string_c);
1576 }
1577
TEST(ByteStringView,NullIterator)1578 TEST(ByteStringView, NullIterator) {
1579 ByteStringView null_str;
1580 int32_t sum = 0;
1581 bool any_present = false;
1582 for (const auto& c : null_str) {
1583 sum += c; // Avoid unused arg warnings.
1584 any_present = true;
1585 }
1586 EXPECT_FALSE(any_present);
1587 EXPECT_EQ(0, sum);
1588 }
1589
TEST(ByteStringView,EmptyIterator)1590 TEST(ByteStringView, EmptyIterator) {
1591 ByteStringView empty_str("");
1592 int32_t sum = 0;
1593 bool any_present = false;
1594 for (const auto& c : empty_str) {
1595 any_present = true;
1596 sum += c; // Avoid unused arg warnings.
1597 }
1598 EXPECT_FALSE(any_present);
1599 EXPECT_EQ(0, sum);
1600 }
1601
TEST(ByteStringView,OneCharIterator)1602 TEST(ByteStringView, OneCharIterator) {
1603 ByteStringView one_str("a");
1604 int32_t sum = 0;
1605 bool any_present = false;
1606 for (const auto& c : one_str) {
1607 any_present = true;
1608 sum += c; // Avoid unused arg warnings.
1609 }
1610 EXPECT_TRUE(any_present);
1611 EXPECT_EQ('a', sum);
1612 }
1613
TEST(ByteStringView,MultiCharIterator)1614 TEST(ByteStringView, MultiCharIterator) {
1615 ByteStringView one_str("abc");
1616 int32_t sum = 0;
1617 bool any_present = false;
1618 for (const auto& c : one_str) {
1619 any_present = true;
1620 sum += c; // Avoid unused arg warnings.
1621 }
1622 EXPECT_TRUE(any_present);
1623 EXPECT_EQ('a' + 'b' + 'c', sum);
1624 }
1625
TEST(ByteStringView,EmptyReverseIterator)1626 TEST(ByteStringView, EmptyReverseIterator) {
1627 ByteStringView empty;
1628 auto iter = empty.rbegin();
1629 EXPECT_TRUE(iter == empty.rend());
1630 EXPECT_FALSE(iter != empty.rend());
1631 EXPECT_FALSE(iter < empty.rend());
1632 }
1633
TEST(ByteStringView,OneCharReverseIterator)1634 TEST(ByteStringView, OneCharReverseIterator) {
1635 ByteStringView one_str("a");
1636 auto iter = one_str.rbegin();
1637 EXPECT_FALSE(iter == one_str.rend());
1638 EXPECT_TRUE(iter != one_str.rend());
1639 EXPECT_TRUE(iter < one_str.rend());
1640
1641 char ch = *iter++;
1642 EXPECT_EQ('a', ch);
1643 EXPECT_TRUE(iter == one_str.rend());
1644 EXPECT_FALSE(iter != one_str.rend());
1645 EXPECT_FALSE(iter < one_str.rend());
1646 }
1647
TEST(ByteStringView,MultiCharReverseIterator)1648 TEST(ByteStringView, MultiCharReverseIterator) {
1649 ByteStringView multi_str("abcd");
1650 auto iter = multi_str.rbegin();
1651 EXPECT_FALSE(iter == multi_str.rend());
1652
1653 char ch = *iter++;
1654 EXPECT_EQ('d', ch);
1655 EXPECT_EQ('c', *iter);
1656 EXPECT_FALSE(iter == multi_str.rend());
1657
1658 ch = *(++iter);
1659 EXPECT_EQ('b', ch);
1660 EXPECT_EQ('b', *iter);
1661 EXPECT_FALSE(iter == multi_str.rend());
1662
1663 ch = *iter++;
1664 EXPECT_EQ('b', ch);
1665 EXPECT_EQ('a', *iter);
1666 EXPECT_FALSE(iter == multi_str.rend());
1667
1668 ch = *iter++;
1669 EXPECT_EQ('a', ch);
1670 EXPECT_TRUE(iter == multi_str.rend());
1671
1672 ch = *(--iter);
1673 EXPECT_EQ('a', ch);
1674 EXPECT_EQ('a', *iter);
1675 EXPECT_FALSE(iter == multi_str.rend());
1676
1677 ch = *iter--;
1678 EXPECT_EQ('a', ch);
1679 EXPECT_EQ('b', *iter);
1680 EXPECT_FALSE(iter == multi_str.rend());
1681
1682 ch = *iter--;
1683 EXPECT_EQ('b', ch);
1684 EXPECT_EQ('c', *iter);
1685 EXPECT_FALSE(iter == multi_str.rend());
1686
1687 ch = *(--iter);
1688 EXPECT_EQ('d', ch);
1689 EXPECT_EQ('d', *iter);
1690 EXPECT_TRUE(iter == multi_str.rbegin());
1691 }
1692
TEST(ByteStringView,AnyAllNoneOf)1693 TEST(ByteStringView, AnyAllNoneOf) {
1694 ByteStringView str("aaaaaaaaaaaaaaaaab");
1695 EXPECT_FALSE(std::all_of(str.begin(), str.end(),
1696 [](const char& c) { return c == 'a'; }));
1697
1698 EXPECT_FALSE(std::none_of(str.begin(), str.end(),
1699 [](const char& c) { return c == 'a'; }));
1700
1701 EXPECT_TRUE(std::any_of(str.begin(), str.end(),
1702 [](const char& c) { return c == 'a'; }));
1703
1704 EXPECT_TRUE(pdfium::Contains(str, 'a'));
1705 EXPECT_TRUE(pdfium::Contains(str, 'b'));
1706 EXPECT_FALSE(pdfium::Contains(str, 'z'));
1707 }
1708
TEST(ByteString,FormatWidth)1709 TEST(ByteString, FormatWidth) {
1710 EXPECT_EQ(" 1", ByteString::Format("%5d", 1));
1711 EXPECT_EQ("1", ByteString::Format("%d", 1));
1712 EXPECT_EQ(" 1", ByteString::Format("%*d", 5, 1));
1713 EXPECT_EQ("1", ByteString::Format("%-1d", 1));
1714 EXPECT_EQ("1", ByteString::Format("%0d", 1));
1715 }
1716
TEST(ByteString,FormatPrecision)1717 TEST(ByteString, FormatPrecision) {
1718 EXPECT_EQ("1.12", ByteString::Format("%.2f", 1.12345));
1719 EXPECT_EQ("1.123", ByteString::Format("%.*f", 3, 1.12345));
1720 EXPECT_EQ("1.123450", ByteString::Format("%f", 1.12345));
1721 EXPECT_EQ("1.123450", ByteString::Format("%-1f", 1.12345));
1722 EXPECT_EQ("1.123450", ByteString::Format("%0f", 1.12345));
1723 }
1724
TEST(ByteString,Empty)1725 TEST(ByteString, Empty) {
1726 ByteString empty_str;
1727 EXPECT_TRUE(empty_str.IsEmpty());
1728 EXPECT_EQ(0u, empty_str.GetLength());
1729
1730 const char* cstr = empty_str.c_str();
1731 EXPECT_TRUE(cstr);
1732 EXPECT_EQ(0u, strlen(cstr));
1733
1734 const uint8_t* rstr = empty_str.raw_str();
1735 EXPECT_FALSE(rstr);
1736
1737 pdfium::span<const char> cspan = empty_str.span();
1738 EXPECT_TRUE(cspan.empty());
1739 EXPECT_FALSE(cspan.data());
1740
1741 pdfium::span<const uint8_t> rspan = empty_str.raw_span();
1742 EXPECT_TRUE(rspan.empty());
1743 EXPECT_FALSE(rspan.data());
1744 }
1745
TEST(ByteString,InitializerList)1746 TEST(ByteString, InitializerList) {
1747 ByteString many_str({"clams", " and ", "oysters"});
1748 EXPECT_EQ("clams and oysters", many_str);
1749 many_str = {"fish", " and ", "chips", " and ", "soda"};
1750 EXPECT_EQ("fish and chips and soda", many_str);
1751 }
1752
TEST(ByteString,NullIterator)1753 TEST(ByteString, NullIterator) {
1754 ByteString null_str;
1755 int32_t sum = 0;
1756 bool any_present = false;
1757 for (const auto& c : null_str) {
1758 sum += c; // Avoid unused arg warnings.
1759 any_present = true;
1760 }
1761 EXPECT_FALSE(any_present);
1762 EXPECT_EQ(0, sum);
1763 }
1764
TEST(ByteString,EmptyIterator)1765 TEST(ByteString, EmptyIterator) {
1766 ByteString empty_str("");
1767 int32_t sum = 0;
1768 bool any_present = false;
1769 for (const auto& c : empty_str) {
1770 any_present = true;
1771 sum += c; // Avoid unused arg warnings.
1772 }
1773 EXPECT_FALSE(any_present);
1774 EXPECT_EQ(0, sum);
1775 }
1776
TEST(ByteString,OneCharIterator)1777 TEST(ByteString, OneCharIterator) {
1778 ByteString one_str("a");
1779 int32_t sum = 0;
1780 bool any_present = false;
1781 for (const auto& c : one_str) {
1782 any_present = true;
1783 sum += c; // Avoid unused arg warnings.
1784 }
1785 EXPECT_TRUE(any_present);
1786 EXPECT_EQ('a', sum);
1787 }
1788
TEST(ByteString,MultiCharIterator)1789 TEST(ByteString, MultiCharIterator) {
1790 ByteString one_str("abc");
1791 int32_t sum = 0;
1792 bool any_present = false;
1793 for (const auto& c : one_str) {
1794 any_present = true;
1795 sum += c; // Avoid unused arg warnings.
1796 }
1797 EXPECT_TRUE(any_present);
1798 EXPECT_EQ('a' + 'b' + 'c', sum);
1799 }
1800
TEST(ByteString,StdBegin)1801 TEST(ByteString, StdBegin) {
1802 ByteString one_str("abc");
1803 std::vector<uint8_t> vec(std::begin(one_str), std::end(one_str));
1804 ASSERT_EQ(3u, vec.size());
1805 EXPECT_EQ('a', vec[0]);
1806 EXPECT_EQ('b', vec[1]);
1807 EXPECT_EQ('c', vec[2]);
1808 }
1809
TEST(ByteString,AnyAllNoneOf)1810 TEST(ByteString, AnyAllNoneOf) {
1811 ByteString str("aaaaaaaaaaaaaaaaab");
1812 EXPECT_FALSE(std::all_of(str.begin(), str.end(),
1813 [](const char& c) { return c == 'a'; }));
1814
1815 EXPECT_FALSE(std::none_of(str.begin(), str.end(),
1816 [](const char& c) { return c == 'a'; }));
1817
1818 EXPECT_TRUE(std::any_of(str.begin(), str.end(),
1819 [](const char& c) { return c == 'a'; }));
1820
1821 EXPECT_TRUE(pdfium::Contains(str, 'a'));
1822 EXPECT_TRUE(pdfium::Contains(str, 'b'));
1823 EXPECT_FALSE(pdfium::Contains(str, 'z'));
1824 }
1825
TEST(CFX_BytrString,EqualNoCase)1826 TEST(CFX_BytrString, EqualNoCase) {
1827 ByteString str("aaa");
1828 EXPECT_TRUE(str.EqualNoCase("aaa"));
1829 EXPECT_TRUE(str.EqualNoCase("AAA"));
1830 EXPECT_TRUE(str.EqualNoCase("aaA"));
1831 EXPECT_TRUE(str.EqualNoCase("Aaa"));
1832 EXPECT_FALSE(str.EqualNoCase("aab"));
1833 EXPECT_FALSE(str.EqualNoCase("aaaa"));
1834 EXPECT_FALSE(str.EqualNoCase("BBBB"));
1835 EXPECT_FALSE(str.EqualNoCase("a"));
1836 EXPECT_FALSE(str.EqualNoCase(""));
1837 }
1838
TEST(ByteString,OStreamOverload)1839 TEST(ByteString, OStreamOverload) {
1840 std::ostringstream stream;
1841
1842 // Basic case, empty string
1843 ByteString str;
1844 stream << str;
1845 EXPECT_EQ("", stream.str());
1846
1847 // Basic case, non-empty string
1848 str = "def";
1849 stream.str("");
1850 stream << "abc" << str << "ghi";
1851 EXPECT_EQ("abcdefghi", stream.str());
1852
1853 // Changing the ByteString does not change the stream it was written to.
1854 str = "123";
1855 EXPECT_EQ("abcdefghi", stream.str());
1856
1857 // Writing it again to the stream will use the latest value.
1858 stream.str("");
1859 stream << "abc" << str << "ghi";
1860 EXPECT_EQ("abc123ghi", stream.str());
1861
1862 char stringWithNulls[]{'x', 'y', '\0', 'z'};
1863
1864 // Writing a ByteString with nulls and no specified length treats it as
1865 // a C-style null-terminated string.
1866 str = ByteString(stringWithNulls);
1867 EXPECT_EQ(2u, str.GetLength());
1868 stream.str("");
1869 stream << str;
1870 EXPECT_EQ(2u, stream.tellp());
1871
1872 // Writing a ByteString with nulls but specifying its length treats it as
1873 // a C++-style string.
1874 str = ByteString(stringWithNulls, 4);
1875 EXPECT_EQ(4u, str.GetLength());
1876 stream.str("");
1877 stream << str;
1878 EXPECT_EQ(4u, stream.tellp());
1879
1880 // << operators can be chained.
1881 ByteString str1("abc");
1882 ByteString str2("def");
1883 stream.str("");
1884 stream << str1 << str2;
1885 EXPECT_EQ("abcdef", stream.str());
1886 }
1887
TEST(ByteStringView,OStreamOverload)1888 TEST(ByteStringView, OStreamOverload) {
1889 // Basic case, empty string
1890 {
1891 std::ostringstream stream;
1892 ByteStringView str;
1893 stream << str;
1894 EXPECT_EQ("", stream.str());
1895 }
1896
1897 // Basic case, non-empty string
1898 {
1899 std::ostringstream stream;
1900 ByteStringView str("def");
1901 stream << "abc" << str << "ghi";
1902 EXPECT_EQ("abcdefghi", stream.str());
1903 }
1904
1905 // Changing the ByteStringView does not change the stream it was written to.
1906 {
1907 std::ostringstream stream;
1908 ByteStringView str("abc");
1909 stream << str;
1910 str = "123";
1911 EXPECT_EQ("abc", stream.str());
1912 }
1913
1914 // Writing it again to the stream will use the latest value.
1915 {
1916 std::ostringstream stream;
1917 ByteStringView str("abc");
1918 stream << str;
1919 stream.str("");
1920 str = "123";
1921 stream << str;
1922 EXPECT_EQ("123", stream.str());
1923 }
1924
1925 // Writing a ByteStringView with nulls and no specified length treats it as
1926 // a C-style null-terminated string.
1927 {
1928 std::ostringstream stream;
1929 char stringWithNulls[]{'x', 'y', '\0', 'z'};
1930 ByteStringView str(stringWithNulls);
1931 EXPECT_EQ(2u, str.GetLength());
1932 stream << str;
1933 EXPECT_EQ(2u, stream.tellp());
1934 str = "";
1935 }
1936
1937 // Writing a ByteStringView with nulls but specifying its length treats it as
1938 // a C++-style string.
1939 {
1940 std::ostringstream stream;
1941 char stringWithNulls[]{'x', 'y', '\0', 'z'};
1942 ByteStringView str(stringWithNulls, 4);
1943 EXPECT_EQ(4u, str.GetLength());
1944 stream << str;
1945 EXPECT_EQ(4u, stream.tellp());
1946 str = "";
1947 }
1948
1949 // << operators can be chained.
1950 {
1951 std::ostringstream stream;
1952 ByteStringView str1("abc");
1953 ByteStringView str2("def");
1954 stream << str1 << str2;
1955 EXPECT_EQ("abcdef", stream.str());
1956 }
1957 }
1958
TEST(ByteString,FormatInteger)1959 TEST(ByteString, FormatInteger) {
1960 // Base case of 0.
1961 EXPECT_EQ("0", ByteString::FormatInteger(0));
1962
1963 // Positive ordinary number.
1964 EXPECT_EQ("123456", ByteString::FormatInteger(123456));
1965
1966 // Negative ordinary number.
1967 EXPECT_EQ("-123456", ByteString::FormatInteger(-123456));
1968
1969 // int limits.
1970 EXPECT_EQ("2147483647", ByteString::FormatInteger(INT_MAX));
1971 EXPECT_EQ("-2147483648", ByteString::FormatInteger(INT_MIN));
1972 }
1973
TEST(ByteString,FX_HashCode_Ascii)1974 TEST(ByteString, FX_HashCode_Ascii) {
1975 EXPECT_EQ(0u, FX_HashCode_GetA(""));
1976 EXPECT_EQ(65u, FX_HashCode_GetA("A"));
1977 EXPECT_EQ(97u, FX_HashCode_GetLoweredA("A"));
1978 EXPECT_EQ(31 * 65u + 66u, FX_HashCode_GetA("AB"));
1979 EXPECT_EQ(31u * 65u + 255u, FX_HashCode_GetA("A\xff"));
1980 EXPECT_EQ(31u * 97u + 255u, FX_HashCode_GetLoweredA("A\xff"));
1981 }
1982
TEST(ByteString,FX_HashCode_Wide)1983 TEST(ByteString, FX_HashCode_Wide) {
1984 EXPECT_EQ(0u, FX_HashCode_GetAsIfW(""));
1985 EXPECT_EQ(65u, FX_HashCode_GetAsIfW("A"));
1986 EXPECT_EQ(97u, FX_HashCode_GetLoweredAsIfW("A"));
1987 EXPECT_EQ(1313u * 65u + 66u, FX_HashCode_GetAsIfW("AB"));
1988 EXPECT_EQ(1313u * 65u + 255u, FX_HashCode_GetAsIfW("A\xff"));
1989 EXPECT_EQ(1313u * 97u + 255u, FX_HashCode_GetLoweredAsIfW("A\xff"));
1990 }
1991
1992 } // namespace fxcrt
1993