1 // Copyright 2016 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 <limits>
6
7 #include "build/build_config.h"
8 #include "core/fxcrt/fx_string.h"
9 #include "core/fxcrt/span.h"
10 #include "core/fxcrt/utf16.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12
TEST(fxstring,FXUTF8Encode)13 TEST(fxstring, FXUTF8Encode) {
14 EXPECT_EQ("", FX_UTF8Encode(WideStringView()));
15 EXPECT_EQ(
16 "x"
17 "\u0080"
18 "\u00ff"
19 "\ud7ff"
20 "\ue000"
21 "\uff2c"
22 "\uffff"
23 "y",
24 FX_UTF8Encode(L"x"
25 L"\u0080"
26 L"\u00ff"
27 L"\ud7ff"
28 L"\ue000"
29 L"\uff2c"
30 L"\uffff"
31 L"y"));
32 }
33
TEST(fxstring,FXUTF8EncodeSupplementary)34 TEST(fxstring, FXUTF8EncodeSupplementary) {
35 EXPECT_EQ(
36 "\U00010000"
37 "��"
38 "\U0010ffff",
39 FX_UTF8Encode(L"\U00010000"
40 L"\U0001f3a8"
41 L"\U0010ffff"));
42 }
43
44 #if defined(WCHAR_T_IS_16_BIT)
TEST(fxstring,FXUTF8EncodeSurrogateErrorRecovery)45 TEST(fxstring, FXUTF8EncodeSurrogateErrorRecovery) {
46 EXPECT_EQ("(\xed\xa0\x80)", FX_UTF8Encode(L"(\xd800)")) << "High";
47 EXPECT_EQ("(\xed\xb0\x80)", FX_UTF8Encode(L"(\xdc00)")) << "Low";
48 EXPECT_EQ("(\xed\xa0\x80��)", FX_UTF8Encode(L"(\xd800\xd83c\xdfa8)"))
49 << "High-high";
50 EXPECT_EQ("(��\xed\xb0\x80)", FX_UTF8Encode(L"(\xd83c\xdfa8\xdc00)"))
51 << "Low-low";
52 }
53 #endif // defined(WCHAR_T_IS_16_BIT)
54
TEST(fxstring,ByteStringToFloat)55 TEST(fxstring, ByteStringToFloat) {
56 EXPECT_FLOAT_EQ(0.0f, StringToFloat(""));
57 EXPECT_FLOAT_EQ(0.0f, StringToFloat("0"));
58 EXPECT_FLOAT_EQ(0.0f, StringToFloat("0.0"));
59 EXPECT_FLOAT_EQ(0.0f, StringToFloat("-0.0"));
60
61 EXPECT_FLOAT_EQ(0.25f, StringToFloat("0.25"));
62 EXPECT_FLOAT_EQ(-0.25f, StringToFloat("-0.25"));
63
64 EXPECT_FLOAT_EQ(100.0f, StringToFloat("100"));
65 EXPECT_FLOAT_EQ(100.0f, StringToFloat("100.0"));
66 EXPECT_FLOAT_EQ(100.0f, StringToFloat(" 100.0"));
67 EXPECT_FLOAT_EQ(-100.0f, StringToFloat("-100.0000"));
68
69 EXPECT_FLOAT_EQ(3.402823e+38f,
70 StringToFloat("340282300000000000000000000000000000000"));
71 EXPECT_FLOAT_EQ(-3.402823e+38f,
72 StringToFloat("-340282300000000000000000000000000000000"));
73
74 EXPECT_FLOAT_EQ(1.000000119f, StringToFloat("1.000000119"));
75 EXPECT_FLOAT_EQ(1.999999881f, StringToFloat("1.999999881"));
76
77 EXPECT_FLOAT_EQ(0.25f, StringToFloat(L"+0.25"));
78
79 EXPECT_FLOAT_EQ(1.2e34f, StringToFloat("1.2e34"));
80
81 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
82 StringToFloat("999999999999999999999999999999999999999"));
83 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::infinity(),
84 StringToFloat("-999999999999999999999999999999999999999"));
85
86 EXPECT_FLOAT_EQ(0.0f, StringToFloat("invalid"));
87
88 // Test the exact float value. Use EXPECT_EQ, which does an exact comparison,
89 // instead of EXPECT_FLOAT_EQ, which allows slight precision error.
90 EXPECT_EQ(38.89528656005859375f, StringToFloat("38.895285"));
91 }
92
TEST(fxstring,WideStringToFloat)93 TEST(fxstring, WideStringToFloat) {
94 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L""));
95 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"0"));
96 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"0.0"));
97 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"-0.0"));
98
99 EXPECT_FLOAT_EQ(0.25f, StringToFloat(L"0.25"));
100 EXPECT_FLOAT_EQ(-0.25f, StringToFloat(L"-0.25"));
101
102 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L"100"));
103 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L"100.0"));
104 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L" 100.0"));
105 EXPECT_FLOAT_EQ(-100.0f, StringToFloat(L"-100.0000"));
106
107 EXPECT_FLOAT_EQ(3.402823e+38f,
108 StringToFloat(L"340282300000000000000000000000000000000"));
109 EXPECT_FLOAT_EQ(-3.402823e+38f,
110 StringToFloat(L"-340282300000000000000000000000000000000"));
111
112 EXPECT_FLOAT_EQ(1.000000119f, StringToFloat(L"1.000000119"));
113 EXPECT_FLOAT_EQ(1.999999881f, StringToFloat(L"1.999999881"));
114
115 EXPECT_FLOAT_EQ(0.25f, StringToFloat(L"+0.25"));
116
117 EXPECT_FLOAT_EQ(1.2e34f, StringToFloat(L"1.2e34"));
118
119 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
120 StringToFloat(L"999999999999999999999999999999999999999"));
121 EXPECT_FLOAT_EQ(-std::numeric_limits<float>::infinity(),
122 StringToFloat(L"-999999999999999999999999999999999999999"));
123
124 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"invalid"));
125
126 // Test the exact float value. Use EXPECT_EQ, which does an exact comparison,
127 // instead of EXPECT_FLOAT_EQ, which allows slight precision error.
128 EXPECT_EQ(38.89528656005859375f, StringToFloat(L"38.895285"));
129 }
130
TEST(fxstring,ByteStringToDouble)131 TEST(fxstring, ByteStringToDouble) {
132 EXPECT_DOUBLE_EQ(0.0, StringToDouble(""));
133 EXPECT_DOUBLE_EQ(0.0, StringToDouble("0"));
134 EXPECT_DOUBLE_EQ(0.0, StringToDouble("0.0"));
135 EXPECT_DOUBLE_EQ(0.0, StringToDouble("-0.0"));
136
137 EXPECT_DOUBLE_EQ(0.25, StringToDouble("0.25"));
138 EXPECT_DOUBLE_EQ(-0.25, StringToDouble("-0.25"));
139
140 EXPECT_DOUBLE_EQ(100.0, StringToDouble("100"));
141 EXPECT_DOUBLE_EQ(100.0, StringToDouble("100.0"));
142 EXPECT_DOUBLE_EQ(100.0, StringToDouble(" 100.0"));
143 EXPECT_DOUBLE_EQ(-100.0, StringToDouble("-100.0000"));
144
145 EXPECT_DOUBLE_EQ(3.402823e+38,
146 StringToDouble("340282300000000000000000000000000000000"));
147 EXPECT_DOUBLE_EQ(-3.402823e+38,
148 StringToDouble("-340282300000000000000000000000000000000"));
149
150 EXPECT_DOUBLE_EQ(1.000000119, StringToDouble("1.000000119"));
151 EXPECT_DOUBLE_EQ(1.999999881, StringToDouble("1.999999881"));
152
153 EXPECT_DOUBLE_EQ(0.25, StringToDouble("+0.25"));
154
155 EXPECT_DOUBLE_EQ(1.2e34, StringToDouble("1.2e34"));
156
157 EXPECT_DOUBLE_EQ(
158 std::numeric_limits<double>::infinity(),
159 StringToDouble(
160 "99999999999999999999999999999999999999999999999999999999999999999999"
161 "99999999999999999999999999999999999999999999999999999999999999999999"
162 "99999999999999999999999999999999999999999999999999999999999999999999"
163 "99999999999999999999999999999999999999999999999999999999999999999999"
164 "99999999999999999999999999999999999999"));
165 EXPECT_DOUBLE_EQ(
166 -std::numeric_limits<double>::infinity(),
167 StringToDouble(
168 "-9999999999999999999999999999999999999999999999999999999999999999999"
169 "99999999999999999999999999999999999999999999999999999999999999999999"
170 "99999999999999999999999999999999999999999999999999999999999999999999"
171 "99999999999999999999999999999999999999999999999999999999999999999999"
172 "99999999999999999999999999999999999999"));
173
174 EXPECT_DOUBLE_EQ(0.0, StringToDouble("invalid"));
175
176 // Test the exact double value. Use EXPECT_EQ, which does an exact comparison,
177 // instead of EXPECT_DOUBLE_EQ, which allows slight precision error.
178 EXPECT_EQ(1.9998779296892903, StringToDouble("1.99987792968929034"));
179 }
180
TEST(fxstring,WideStringToDouble)181 TEST(fxstring, WideStringToDouble) {
182 EXPECT_DOUBLE_EQ(0.0, StringToDouble(L""));
183 EXPECT_DOUBLE_EQ(0.0, StringToDouble(L"0"));
184 EXPECT_DOUBLE_EQ(0.0, StringToDouble(L"0.0"));
185 EXPECT_DOUBLE_EQ(0.0, StringToDouble(L"-0.0"));
186
187 EXPECT_DOUBLE_EQ(0.25, StringToDouble(L"0.25"));
188 EXPECT_DOUBLE_EQ(-0.25, StringToDouble(L"-0.25"));
189
190 EXPECT_DOUBLE_EQ(100.0, StringToDouble(L"100"));
191 EXPECT_DOUBLE_EQ(100.0, StringToDouble(L"100.0"));
192 EXPECT_DOUBLE_EQ(100.0, StringToDouble(L" 100.0"));
193 EXPECT_DOUBLE_EQ(-100.0, StringToDouble(L"-100.0000"));
194
195 EXPECT_DOUBLE_EQ(3.402823e+38,
196 StringToDouble(L"340282300000000000000000000000000000000"));
197 EXPECT_DOUBLE_EQ(-3.402823e+38,
198 StringToDouble(L"-340282300000000000000000000000000000000"));
199
200 EXPECT_DOUBLE_EQ(1.000000119, StringToDouble(L"1.000000119"));
201 EXPECT_DOUBLE_EQ(1.999999881, StringToDouble(L"1.999999881"));
202
203 EXPECT_DOUBLE_EQ(0.25, StringToDouble(L"+0.25"));
204
205 EXPECT_DOUBLE_EQ(1.2e34, StringToDouble(L"1.2e34"));
206
207 EXPECT_DOUBLE_EQ(
208 std::numeric_limits<double>::infinity(),
209 StringToDouble(
210 L"9999999999999999999999999999999999999999999999999999999999999999999"
211 L"9999999999999999999999999999999999999999999999999999999999999999999"
212 L"9999999999999999999999999999999999999999999999999999999999999999999"
213 L"9999999999999999999999999999999999999999999999999999999999999999999"
214 L"999999999999999999999999999999999999999999"));
215 EXPECT_DOUBLE_EQ(
216 -std::numeric_limits<double>::infinity(),
217 StringToDouble(
218 L"-999999999999999999999999999999999999999999999999999999999999999999"
219 L"9999999999999999999999999999999999999999999999999999999999999999999"
220 L"9999999999999999999999999999999999999999999999999999999999999999999"
221 L"9999999999999999999999999999999999999999999999999999999999999999999"
222 L"999999999999999999999999999999999999999999"));
223
224 EXPECT_DOUBLE_EQ(0.0, StringToDouble(L"invalid"));
225
226 // Test the exact double value. Use EXPECT_EQ, which does an exact comparison,
227 // instead of EXPECT_DOUBLE_EQ, which allows slight precision error.
228 EXPECT_EQ(1.9998779296892903, StringToDouble(L"1.99987792968929034"));
229 }
230
TEST(fxstring,SplitByteString)231 TEST(fxstring, SplitByteString) {
232 std::vector<ByteString> result;
233 result = fxcrt::Split(ByteString(""), ',');
234 ASSERT_EQ(1u, result.size());
235 EXPECT_EQ("", result[0]);
236
237 result = fxcrt::Split(ByteString("a"), ',');
238 ASSERT_EQ(1u, result.size());
239 EXPECT_EQ("a", result[0]);
240
241 result = fxcrt::Split(ByteString(","), ',');
242 ASSERT_EQ(2u, result.size());
243 EXPECT_EQ("", result[0]);
244 EXPECT_EQ("", result[1]);
245
246 result = fxcrt::Split(ByteString("a,"), ',');
247 ASSERT_EQ(2u, result.size());
248 EXPECT_EQ("a", result[0]);
249 EXPECT_EQ("", result[1]);
250
251 result = fxcrt::Split(ByteString(",b"), ',');
252 ASSERT_EQ(2u, result.size());
253 EXPECT_EQ("", result[0]);
254 EXPECT_EQ("b", result[1]);
255
256 result = fxcrt::Split(ByteString("a,b"), ',');
257 ASSERT_EQ(2u, result.size());
258 EXPECT_EQ("a", result[0]);
259 EXPECT_EQ("b", result[1]);
260
261 result = fxcrt::Split(ByteString("a,b,"), ',');
262 ASSERT_EQ(3u, result.size());
263 EXPECT_EQ("a", result[0]);
264 EXPECT_EQ("b", result[1]);
265 EXPECT_EQ("", result[2]);
266
267 result = fxcrt::Split(ByteString("a,,"), ',');
268 ASSERT_EQ(3u, result.size());
269 EXPECT_EQ("a", result[0]);
270 EXPECT_EQ("", result[1]);
271 EXPECT_EQ("", result[2]);
272
273 result = fxcrt::Split(ByteString(",,a"), ',');
274 ASSERT_EQ(3u, result.size());
275 EXPECT_EQ("", result[0]);
276 EXPECT_EQ("", result[1]);
277 EXPECT_EQ("a", result[2]);
278 }
279
TEST(fxstring,SplitByteStringView)280 TEST(fxstring, SplitByteStringView) {
281 std::vector<ByteStringView> result;
282 result = fxcrt::Split(ByteStringView(""), ',');
283 ASSERT_EQ(1u, result.size());
284 EXPECT_EQ("", result[0]);
285
286 result = fxcrt::Split(ByteStringView("a"), ',');
287 ASSERT_EQ(1u, result.size());
288 EXPECT_EQ("a", result[0]);
289
290 result = fxcrt::Split(ByteStringView(","), ',');
291 ASSERT_EQ(2u, result.size());
292 EXPECT_EQ("", result[0]);
293 EXPECT_EQ("", result[1]);
294
295 result = fxcrt::Split(ByteStringView("a,"), ',');
296 ASSERT_EQ(2u, result.size());
297 EXPECT_EQ("a", result[0]);
298 EXPECT_EQ("", result[1]);
299
300 result = fxcrt::Split(ByteStringView(",b"), ',');
301 ASSERT_EQ(2u, result.size());
302 EXPECT_EQ("", result[0]);
303 EXPECT_EQ("b", result[1]);
304
305 result = fxcrt::Split(ByteStringView("a,b"), ',');
306 ASSERT_EQ(2u, result.size());
307 EXPECT_EQ("a", result[0]);
308 EXPECT_EQ("b", result[1]);
309
310 result = fxcrt::Split(ByteStringView("a,b,"), ',');
311 ASSERT_EQ(3u, result.size());
312 EXPECT_EQ("a", result[0]);
313 EXPECT_EQ("b", result[1]);
314 EXPECT_EQ("", result[2]);
315
316 result = fxcrt::Split(ByteStringView("a,,"), ',');
317 ASSERT_EQ(3u, result.size());
318 EXPECT_EQ("a", result[0]);
319 EXPECT_EQ("", result[1]);
320 EXPECT_EQ("", result[2]);
321
322 result = fxcrt::Split(ByteStringView(",,a"), ',');
323 ASSERT_EQ(3u, result.size());
324 EXPECT_EQ("", result[0]);
325 EXPECT_EQ("", result[1]);
326 EXPECT_EQ("a", result[2]);
327 }
328
TEST(fxstring,SplitWideString)329 TEST(fxstring, SplitWideString) {
330 std::vector<WideString> result;
331 result = fxcrt::Split(WideString(L""), L',');
332 ASSERT_EQ(1u, result.size());
333 EXPECT_EQ(L"", result[0]);
334
335 result = fxcrt::Split(WideString(L"a"), L',');
336 ASSERT_EQ(1u, result.size());
337 EXPECT_EQ(L"a", result[0]);
338
339 result = fxcrt::Split(WideString(L","), L',');
340 ASSERT_EQ(2u, result.size());
341 EXPECT_EQ(L"", result[0]);
342 EXPECT_EQ(L"", result[1]);
343
344 result = fxcrt::Split(WideString(L"a,"), L',');
345 ASSERT_EQ(2u, result.size());
346 EXPECT_EQ(L"a", result[0]);
347 EXPECT_EQ(L"", result[1]);
348
349 result = fxcrt::Split(WideString(L",b"), L',');
350 ASSERT_EQ(2u, result.size());
351 EXPECT_EQ(L"", result[0]);
352 EXPECT_EQ(L"b", result[1]);
353
354 result = fxcrt::Split(WideString(L"a,b"), L',');
355 ASSERT_EQ(2u, result.size());
356 EXPECT_EQ(L"a", result[0]);
357 EXPECT_EQ(L"b", result[1]);
358
359 result = fxcrt::Split(WideString(L"a,b,"), L',');
360 ASSERT_EQ(3u, result.size());
361 EXPECT_EQ(L"a", result[0]);
362 EXPECT_EQ(L"b", result[1]);
363 EXPECT_EQ(L"", result[2]);
364
365 result = fxcrt::Split(WideString(L"a,,"), L',');
366 ASSERT_EQ(3u, result.size());
367 EXPECT_EQ(L"a", result[0]);
368 EXPECT_EQ(L"", result[1]);
369 EXPECT_EQ(L"", result[2]);
370
371 result = fxcrt::Split(WideString(L",,a"), L',');
372 ASSERT_EQ(3u, result.size());
373 EXPECT_EQ(L"", result[0]);
374 EXPECT_EQ(L"", result[1]);
375 EXPECT_EQ(L"a", result[2]);
376 }
377
TEST(fxstring,SplitWideStringView)378 TEST(fxstring, SplitWideStringView) {
379 std::vector<WideStringView> result;
380 result = fxcrt::Split(WideStringView(L""), L',');
381 ASSERT_EQ(1u, result.size());
382 EXPECT_EQ(L"", result[0]);
383
384 result = fxcrt::Split(WideStringView(L"a"), L',');
385 ASSERT_EQ(1u, result.size());
386 EXPECT_EQ(L"a", result[0]);
387
388 result = fxcrt::Split(WideStringView(L","), L',');
389 ASSERT_EQ(2u, result.size());
390 EXPECT_EQ(L"", result[0]);
391 EXPECT_EQ(L"", result[1]);
392
393 result = fxcrt::Split(WideStringView(L"a,"), L',');
394 ASSERT_EQ(2u, result.size());
395 EXPECT_EQ(L"a", result[0]);
396 EXPECT_EQ(L"", result[1]);
397
398 result = fxcrt::Split(WideStringView(L",b"), L',');
399 ASSERT_EQ(2u, result.size());
400 EXPECT_EQ(L"", result[0]);
401 EXPECT_EQ(L"b", result[1]);
402
403 result = fxcrt::Split(WideStringView(L"a,b"), L',');
404 ASSERT_EQ(2u, result.size());
405 EXPECT_EQ(L"a", result[0]);
406 EXPECT_EQ(L"b", result[1]);
407
408 result = fxcrt::Split(WideStringView(L"a,b,"), L',');
409 ASSERT_EQ(3u, result.size());
410 EXPECT_EQ(L"a", result[0]);
411 EXPECT_EQ(L"b", result[1]);
412 EXPECT_EQ(L"", result[2]);
413
414 result = fxcrt::Split(WideStringView(L"a,,"), L',');
415 ASSERT_EQ(3u, result.size());
416 EXPECT_EQ(L"a", result[0]);
417 EXPECT_EQ(L"", result[1]);
418 EXPECT_EQ(L"", result[2]);
419
420 result = fxcrt::Split(WideStringView(L",,a"), L',');
421 ASSERT_EQ(3u, result.size());
422 EXPECT_EQ(L"", result[0]);
423 EXPECT_EQ(L"", result[1]);
424 EXPECT_EQ(L"a", result[2]);
425 }
426
TEST(fxstring,ByteStringSplitEfficiency)427 TEST(fxstring, ByteStringSplitEfficiency) {
428 std::vector<char> commas(50000, ',');
429 auto input = ByteString(ByteStringView(commas));
430 std::vector<ByteString> result;
431 result = fxcrt::Split(input, ',');
432 ASSERT_EQ(commas.size() + 1, result.size());
433 EXPECT_EQ("", result.front());
434 EXPECT_EQ("", result.back());
435 }
436
TEST(fxstring,ByteStringViewSplitEfficiency)437 TEST(fxstring, ByteStringViewSplitEfficiency) {
438 std::vector<char> commas(50000, ',');
439 ByteStringView input(commas);
440 std::vector<ByteStringView> result;
441 result = fxcrt::Split(input, ',');
442 ASSERT_EQ(commas.size() + 1, result.size());
443 EXPECT_EQ("", result.front());
444 EXPECT_EQ("", result.back());
445 }
446
TEST(fxstring,WideStringSplitEfficiency)447 TEST(fxstring, WideStringSplitEfficiency) {
448 std::vector<wchar_t> commas(50000, L',');
449 auto input = WideString(WideStringView(commas));
450 std::vector<WideString> result;
451 result = fxcrt::Split(input, ',');
452 ASSERT_EQ(commas.size() + 1, result.size());
453 EXPECT_EQ(L"", result.front());
454 EXPECT_EQ(L"", result.back());
455 }
456
TEST(fxstring,WideStringViewSplitEfficiency)457 TEST(fxstring, WideStringViewSplitEfficiency) {
458 std::vector<wchar_t> commas(50000, L',');
459 WideStringView input(commas);
460 std::vector<WideStringView> result;
461 result = fxcrt::Split(input, ',');
462 ASSERT_EQ(commas.size() + 1, result.size());
463 EXPECT_EQ(L"", result.front());
464 EXPECT_EQ(L"", result.back());
465 }
466