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/utf16.h"
10 #include "testing/gtest/include/gtest/gtest.h"
11 #include "third_party/base/containers/span.h"
12
TerminatedFloatToString(float value,pdfium::span<char> buf)13 char* TerminatedFloatToString(float value, pdfium::span<char> buf) {
14 size_t buflen = FloatToString(value, buf);
15 buf[buflen] = '\0';
16 return buf.data();
17 }
18
TerminatedDoubleToString(double value,pdfium::span<char> buf)19 char* TerminatedDoubleToString(double value, pdfium::span<char> buf) {
20 size_t buflen = DoubleToString(value, buf);
21 buf[buflen] = '\0';
22 return buf.data();
23 }
24
TEST(fxstring,FXUTF8Encode)25 TEST(fxstring, FXUTF8Encode) {
26 EXPECT_EQ("", FX_UTF8Encode(WideStringView()));
27 EXPECT_EQ(
28 "x"
29 "\u0080"
30 "\u00ff"
31 "\ud7ff"
32 "\ue000"
33 "\uff2c"
34 "\uffff"
35 "y",
36 FX_UTF8Encode(L"x"
37 L"\u0080"
38 L"\u00ff"
39 L"\ud7ff"
40 L"\ue000"
41 L"\uff2c"
42 L"\uffff"
43 L"y"));
44 }
45
TEST(fxstring,FXUTF8EncodeSupplementary)46 TEST(fxstring, FXUTF8EncodeSupplementary) {
47 EXPECT_EQ(
48 "\U00010000"
49 "��"
50 "\U0010ffff",
51 FX_UTF8Encode(L"\U00010000"
52 L"\U0001f3a8"
53 L"\U0010ffff"));
54 }
55
56 #if defined(WCHAR_T_IS_UTF16)
TEST(fxstring,FXUTF8EncodeSurrogateErrorRecovery)57 TEST(fxstring, FXUTF8EncodeSurrogateErrorRecovery) {
58 EXPECT_EQ("(\xed\xa0\x80)", FX_UTF8Encode(L"(\xd800)")) << "High";
59 EXPECT_EQ("(\xed\xb0\x80)", FX_UTF8Encode(L"(\xdc00)")) << "Low";
60 EXPECT_EQ("(\xed\xa0\x80��)", FX_UTF8Encode(L"(\xd800\xd83c\xdfa8)"))
61 << "High-high";
62 EXPECT_EQ("(��\xed\xb0\x80)", FX_UTF8Encode(L"(\xd83c\xdfa8\xdc00)"))
63 << "Low-low";
64 }
65 #endif // defined(WCHAR_T_IS_UTF16)
66
TEST(fxstring,FXUTF8Decode)67 TEST(fxstring, FXUTF8Decode) {
68 EXPECT_EQ(L"", FX_UTF8Decode(ByteStringView()));
69 EXPECT_EQ(
70 L"x"
71 L"\u0080"
72 L"\u00ff"
73 L"\ud7ff"
74 L"\ue000"
75 L"\uff2c"
76 L"\uffff"
77 L"y",
78 FX_UTF8Decode("x"
79 "\u0080"
80 "\u00ff"
81 "\ud7ff"
82 "\ue000"
83 "\uff2c"
84 "\uffff"
85 "y"));
86 }
87
TEST(fxstring,FXUTF8DecodeSupplementary)88 TEST(fxstring, FXUTF8DecodeSupplementary) {
89 EXPECT_EQ(
90 L"\U00010000"
91 L"\U0001f3a8"
92 L"\U0010ffff",
93 FX_UTF8Decode("\U00010000"
94 "��"
95 "\U0010ffff"));
96 }
97
TEST(fxstring,FXUTF8DecodeErrorRecovery)98 TEST(fxstring, FXUTF8DecodeErrorRecovery) {
99 EXPECT_EQ(L"(A)", FX_UTF8Decode("(\xc2\x41)")) << "Invalid continuation";
100 EXPECT_EQ(L"()", FX_UTF8Decode("(\xc2\xc2)")) << "Invalid continuation";
101 EXPECT_EQ(L"()", FX_UTF8Decode("(\xc2\xff\x80)")) << "Invalid continuation";
102 EXPECT_EQ(L"()", FX_UTF8Decode("(\x80\x80)")) << "Invalid leading";
103 EXPECT_EQ(L"()", FX_UTF8Decode("(\xff\x80\x80)")) << "Invalid leading";
104 EXPECT_EQ(L"()", FX_UTF8Decode("(\xf8\x80\x80\x80\x80)"))
105 << "Invalid leading";
106 EXPECT_EQ(L"()", FX_UTF8Decode("(\xf8\x88\x80\x80\x80)"))
107 << "Invalid leading";
108 EXPECT_EQ(L"()", FX_UTF8Decode("(\xf4\x90\x80\x80)"))
109 << "Code point greater than U+10FFFF";
110 }
111
TEST(fxstring,FXUTF8EncodeDecodeConsistency)112 TEST(fxstring, FXUTF8EncodeDecodeConsistency) {
113 WideString wstr;
114 wstr.Reserve(0x10000);
115 for (char32_t w = 0; w < pdfium::kMinimumSupplementaryCodePoint; ++w) {
116 if (pdfium::IsHighSurrogate(w) || pdfium::IsLowSurrogate(w)) {
117 // Skip UTF-16 surrogates.
118 continue;
119 }
120 wstr += static_cast<wchar_t>(w);
121 }
122 ASSERT_EQ(0xf800u, wstr.GetLength());
123
124 ByteString bstr = FX_UTF8Encode(wstr.AsStringView());
125 WideString wstr2 = FX_UTF8Decode(bstr.AsStringView());
126 EXPECT_EQ(wstr, wstr2);
127 }
128
TEST(fxstring,FXUTF8EncodeDecodeConsistencyUnpairedHighSurrogates)129 TEST(fxstring, FXUTF8EncodeDecodeConsistencyUnpairedHighSurrogates) {
130 WideString wstr;
131 wstr.Reserve(0x400);
132 for (wchar_t w = pdfium::kMinimumHighSurrogateCodeUnit;
133 w <= pdfium::kMaximumHighSurrogateCodeUnit; ++w) {
134 wstr += w;
135 }
136 ASSERT_EQ(0x400u, wstr.GetLength());
137
138 ByteString bstr = FX_UTF8Encode(wstr.AsStringView());
139 WideString wstr2 = FX_UTF8Decode(bstr.AsStringView());
140 EXPECT_EQ(wstr, wstr2);
141 }
142
TEST(fxstring,FXUTF8EncodeDecodeConsistencyUnpairedLowSurrogates)143 TEST(fxstring, FXUTF8EncodeDecodeConsistencyUnpairedLowSurrogates) {
144 WideString wstr;
145 wstr.Reserve(0x400);
146 for (wchar_t w = pdfium::kMinimumLowSurrogateCodeUnit;
147 w <= pdfium::kMaximumLowSurrogateCodeUnit; ++w) {
148 wstr += w;
149 }
150 ASSERT_EQ(0x400u, wstr.GetLength());
151
152 ByteString bstr = FX_UTF8Encode(wstr.AsStringView());
153 WideString wstr2 = FX_UTF8Decode(bstr.AsStringView());
154 EXPECT_EQ(wstr, wstr2);
155 }
156
TEST(fxstring,ByteStringToFloat)157 TEST(fxstring, ByteStringToFloat) {
158 EXPECT_FLOAT_EQ(0.0f, StringToFloat(""));
159 EXPECT_FLOAT_EQ(0.0f, StringToFloat("0"));
160 EXPECT_FLOAT_EQ(0.0f, StringToFloat("0.0"));
161 EXPECT_FLOAT_EQ(0.0f, StringToFloat("-0.0"));
162
163 EXPECT_FLOAT_EQ(0.25f, StringToFloat("0.25"));
164 EXPECT_FLOAT_EQ(-0.25f, StringToFloat("-0.25"));
165
166 EXPECT_FLOAT_EQ(100.0f, StringToFloat("100"));
167 EXPECT_FLOAT_EQ(100.0f, StringToFloat("100.0"));
168 EXPECT_FLOAT_EQ(100.0f, StringToFloat(" 100.0"));
169 EXPECT_FLOAT_EQ(-100.0f, StringToFloat("-100.0000"));
170
171 EXPECT_FLOAT_EQ(3.402823e+38f,
172 StringToFloat("340282300000000000000000000000000000000"));
173 EXPECT_FLOAT_EQ(-3.402823e+38f,
174 StringToFloat("-340282300000000000000000000000000000000"));
175
176 EXPECT_FLOAT_EQ(1.000000119f, StringToFloat("1.000000119"));
177 EXPECT_FLOAT_EQ(1.999999881f, StringToFloat("1.999999881"));
178 }
179
TEST(fxstring,WideStringToFloat)180 TEST(fxstring, WideStringToFloat) {
181 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L""));
182 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"0"));
183 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"0.0"));
184 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"-0.0"));
185
186 EXPECT_FLOAT_EQ(0.25f, StringToFloat(L"0.25"));
187 EXPECT_FLOAT_EQ(-0.25f, StringToFloat(L"-0.25"));
188
189 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L"100"));
190 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L"100.0"));
191 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L" 100.0"));
192 EXPECT_FLOAT_EQ(-100.0f, StringToFloat(L"-100.0000"));
193
194 EXPECT_FLOAT_EQ(3.402823e+38f,
195 StringToFloat(L"340282300000000000000000000000000000000"));
196 EXPECT_FLOAT_EQ(-3.402823e+38f,
197 StringToFloat(L"-340282300000000000000000000000000000000"));
198
199 EXPECT_FLOAT_EQ(1.000000119f, StringToFloat(L"1.000000119"));
200 EXPECT_FLOAT_EQ(1.999999881f, StringToFloat(L"1.999999881"));
201 }
202
TEST(fxstring,FloatToString)203 TEST(fxstring, FloatToString) {
204 char buf[32];
205
206 EXPECT_STREQ("0", TerminatedFloatToString(0.0f, buf));
207 EXPECT_STREQ("0", TerminatedFloatToString(-0.0f, buf));
208 EXPECT_STREQ("0",
209 TerminatedFloatToString(std::numeric_limits<float>::min(), buf));
210 EXPECT_STREQ(
211 "0", TerminatedFloatToString(-std::numeric_limits<float>::min(), buf));
212
213 EXPECT_STREQ("0.25", TerminatedFloatToString(0.25f, buf));
214 EXPECT_STREQ("-0.25", TerminatedFloatToString(-0.25f, buf));
215
216 EXPECT_STREQ("100", TerminatedFloatToString(100.0f, buf));
217 EXPECT_STREQ("-100", TerminatedFloatToString(-100.0f, buf));
218
219 // FloatToString won't convert beyond the maximum integer, and values
220 // larger than that get converted to a string representing that.
221 EXPECT_STREQ("2147483647", TerminatedFloatToString(2147483647.0f, buf));
222 EXPECT_STREQ("2147483647", TerminatedFloatToString(2147483647.5f, buf));
223 EXPECT_STREQ("2147483647",
224 TerminatedFloatToString(std::numeric_limits<float>::max(), buf));
225
226 // FloatToString won't convert beyond the minimum integer, and values
227 // smaller than that get converted to a string representing that.
228 EXPECT_STREQ("-2147483647", TerminatedFloatToString(-2147483647.0f, buf));
229 EXPECT_STREQ("-2147483647", TerminatedFloatToString(-2147483647.5f, buf));
230 EXPECT_STREQ("-2147483647", TerminatedFloatToString(
231 -std::numeric_limits<float>::max(), buf));
232
233 // Conversion only acknowledges precision to 5 digit past decimal, and
234 // rounds beyond that.
235 EXPECT_STREQ("1", TerminatedFloatToString(1.000001119f, buf));
236 EXPECT_STREQ("1.00001", TerminatedFloatToString(1.000011119f, buf));
237 EXPECT_STREQ("1.99999", TerminatedFloatToString(1.999988881f, buf));
238 EXPECT_STREQ("2", TerminatedFloatToString(1.999999881f, buf));
239 }
240
TEST(fxstring,ByteStringToDouble)241 TEST(fxstring, ByteStringToDouble) {
242 EXPECT_FLOAT_EQ(0.0, StringToDouble(""));
243 EXPECT_FLOAT_EQ(0.0, StringToDouble("0"));
244 EXPECT_FLOAT_EQ(0.0, StringToDouble("0.0"));
245 EXPECT_FLOAT_EQ(0.0, StringToDouble("-0.0"));
246
247 EXPECT_FLOAT_EQ(0.25, StringToDouble("0.25"));
248 EXPECT_FLOAT_EQ(-0.25, StringToDouble("-0.25"));
249
250 EXPECT_FLOAT_EQ(100.0, StringToDouble("100"));
251 EXPECT_FLOAT_EQ(100.0, StringToDouble("100.0"));
252 EXPECT_FLOAT_EQ(100.0, StringToDouble(" 100.0"));
253 EXPECT_FLOAT_EQ(-100.0, StringToDouble("-100.0000"));
254
255 EXPECT_FLOAT_EQ(3.402823e+38,
256 StringToDouble("340282300000000000000000000000000000000"));
257 EXPECT_FLOAT_EQ(-3.402823e+38,
258 StringToDouble("-340282300000000000000000000000000000000"));
259
260 EXPECT_FLOAT_EQ(1.000000119, StringToDouble("1.000000119"));
261 EXPECT_FLOAT_EQ(1.999999881, StringToDouble("1.999999881"));
262 }
263
TEST(fxstring,WideStringToDouble)264 TEST(fxstring, WideStringToDouble) {
265 EXPECT_FLOAT_EQ(0.0, StringToDouble(L""));
266 EXPECT_FLOAT_EQ(0.0, StringToDouble(L"0"));
267 EXPECT_FLOAT_EQ(0.0, StringToDouble(L"0.0"));
268 EXPECT_FLOAT_EQ(0.0, StringToDouble(L"-0.0"));
269
270 EXPECT_FLOAT_EQ(0.25, StringToDouble(L"0.25"));
271 EXPECT_FLOAT_EQ(-0.25, StringToDouble(L"-0.25"));
272
273 EXPECT_FLOAT_EQ(100.0, StringToDouble(L"100"));
274 EXPECT_FLOAT_EQ(100.0, StringToDouble(L"100.0"));
275 EXPECT_FLOAT_EQ(100.0, StringToDouble(L" 100.0"));
276 EXPECT_FLOAT_EQ(-100.0, StringToDouble(L"-100.0000"));
277
278 EXPECT_FLOAT_EQ(3.402823e+38,
279 StringToDouble(L"340282300000000000000000000000000000000"));
280 EXPECT_FLOAT_EQ(-3.402823e+38,
281 StringToDouble(L"-340282300000000000000000000000000000000"));
282
283 EXPECT_FLOAT_EQ(1.000000119, StringToDouble(L"1.000000119"));
284 EXPECT_FLOAT_EQ(1.999999881, StringToDouble(L"1.999999881"));
285 }
286
TEST(fxstring,DoubleToString)287 TEST(fxstring, DoubleToString) {
288 char buf[32];
289
290 EXPECT_STREQ("0", TerminatedDoubleToString(0.0f, buf));
291 EXPECT_STREQ("0", TerminatedDoubleToString(-0.0f, buf));
292 EXPECT_STREQ(
293 "0", TerminatedDoubleToString(std::numeric_limits<double>::min(), buf));
294 EXPECT_STREQ(
295 "0", TerminatedDoubleToString(-std::numeric_limits<double>::min(), buf));
296
297 EXPECT_STREQ("0.25", TerminatedDoubleToString(0.25f, buf));
298 EXPECT_STREQ("-0.25", TerminatedDoubleToString(-0.25f, buf));
299
300 EXPECT_STREQ("100", TerminatedDoubleToString(100.0f, buf));
301 EXPECT_STREQ("-100", TerminatedDoubleToString(-100.0f, buf));
302
303 // DoubleToString won't convert beyond the maximum integer, and values
304 // larger than that get converted to a string representing that.
305 EXPECT_STREQ("2147483647", TerminatedDoubleToString(2147483647.0f, buf));
306 EXPECT_STREQ("2147483647", TerminatedDoubleToString(2147483647.5f, buf));
307 EXPECT_STREQ("2147483647", TerminatedDoubleToString(
308 std::numeric_limits<double>::max(), buf));
309
310 // DoubleToString won't convert beyond the minimum integer, and values
311 // smaller than that get converted to a string representing that.
312 EXPECT_STREQ("-2147483647", TerminatedDoubleToString(-2147483647.0f, buf));
313 EXPECT_STREQ("-2147483647", TerminatedDoubleToString(-2147483647.5f, buf));
314 EXPECT_STREQ("-2147483647", TerminatedDoubleToString(
315 -std::numeric_limits<double>::max(), buf));
316
317 // Conversion only acknowledges precision to 5 digit past decimal, and
318 // rounds beyond that.
319 EXPECT_STREQ("1", TerminatedDoubleToString(1.000001119f, buf));
320 EXPECT_STREQ("1.00001", TerminatedDoubleToString(1.000011119f, buf));
321 EXPECT_STREQ("1.99999", TerminatedDoubleToString(1.999988881f, buf));
322 EXPECT_STREQ("2", TerminatedDoubleToString(1.999999881f, buf));
323 }
324
TEST(fxstring,SplitByteString)325 TEST(fxstring, SplitByteString) {
326 std::vector<ByteString> result;
327 result = fxcrt::Split(ByteString(""), ',');
328 ASSERT_EQ(1u, result.size());
329 EXPECT_EQ("", result[0]);
330
331 result = fxcrt::Split(ByteString("a"), ',');
332 ASSERT_EQ(1u, result.size());
333 EXPECT_EQ("a", result[0]);
334
335 result = fxcrt::Split(ByteString(","), ',');
336 ASSERT_EQ(2u, result.size());
337 EXPECT_EQ("", result[0]);
338 EXPECT_EQ("", result[1]);
339
340 result = fxcrt::Split(ByteString("a,"), ',');
341 ASSERT_EQ(2u, result.size());
342 EXPECT_EQ("a", result[0]);
343 EXPECT_EQ("", result[1]);
344
345 result = fxcrt::Split(ByteString(",b"), ',');
346 ASSERT_EQ(2u, result.size());
347 EXPECT_EQ("", result[0]);
348 EXPECT_EQ("b", result[1]);
349
350 result = fxcrt::Split(ByteString("a,b"), ',');
351 ASSERT_EQ(2u, result.size());
352 EXPECT_EQ("a", result[0]);
353 EXPECT_EQ("b", result[1]);
354
355 result = fxcrt::Split(ByteString("a,b,"), ',');
356 ASSERT_EQ(3u, result.size());
357 EXPECT_EQ("a", result[0]);
358 EXPECT_EQ("b", result[1]);
359 EXPECT_EQ("", result[2]);
360
361 result = fxcrt::Split(ByteString("a,,"), ',');
362 ASSERT_EQ(3u, result.size());
363 EXPECT_EQ("a", result[0]);
364 EXPECT_EQ("", result[1]);
365 EXPECT_EQ("", result[2]);
366
367 result = fxcrt::Split(ByteString(",,a"), ',');
368 ASSERT_EQ(3u, result.size());
369 EXPECT_EQ("", result[0]);
370 EXPECT_EQ("", result[1]);
371 EXPECT_EQ("a", result[2]);
372 }
373
TEST(fxstring,SplitByteStringView)374 TEST(fxstring, SplitByteStringView) {
375 std::vector<ByteStringView> result;
376 result = fxcrt::Split(ByteStringView(""), ',');
377 ASSERT_EQ(1u, result.size());
378 EXPECT_EQ("", result[0]);
379
380 result = fxcrt::Split(ByteStringView("a"), ',');
381 ASSERT_EQ(1u, result.size());
382 EXPECT_EQ("a", result[0]);
383
384 result = fxcrt::Split(ByteStringView(","), ',');
385 ASSERT_EQ(2u, result.size());
386 EXPECT_EQ("", result[0]);
387 EXPECT_EQ("", result[1]);
388
389 result = fxcrt::Split(ByteStringView("a,"), ',');
390 ASSERT_EQ(2u, result.size());
391 EXPECT_EQ("a", result[0]);
392 EXPECT_EQ("", result[1]);
393
394 result = fxcrt::Split(ByteStringView(",b"), ',');
395 ASSERT_EQ(2u, result.size());
396 EXPECT_EQ("", result[0]);
397 EXPECT_EQ("b", result[1]);
398
399 result = fxcrt::Split(ByteStringView("a,b"), ',');
400 ASSERT_EQ(2u, result.size());
401 EXPECT_EQ("a", result[0]);
402 EXPECT_EQ("b", result[1]);
403
404 result = fxcrt::Split(ByteStringView("a,b,"), ',');
405 ASSERT_EQ(3u, result.size());
406 EXPECT_EQ("a", result[0]);
407 EXPECT_EQ("b", result[1]);
408 EXPECT_EQ("", result[2]);
409
410 result = fxcrt::Split(ByteStringView("a,,"), ',');
411 ASSERT_EQ(3u, result.size());
412 EXPECT_EQ("a", result[0]);
413 EXPECT_EQ("", result[1]);
414 EXPECT_EQ("", result[2]);
415
416 result = fxcrt::Split(ByteStringView(",,a"), ',');
417 ASSERT_EQ(3u, result.size());
418 EXPECT_EQ("", result[0]);
419 EXPECT_EQ("", result[1]);
420 EXPECT_EQ("a", result[2]);
421 }
422
TEST(fxstring,SplitWideString)423 TEST(fxstring, SplitWideString) {
424 std::vector<WideString> result;
425 result = fxcrt::Split(WideString(L""), L',');
426 ASSERT_EQ(1u, result.size());
427 EXPECT_EQ(L"", result[0]);
428
429 result = fxcrt::Split(WideString(L"a"), L',');
430 ASSERT_EQ(1u, result.size());
431 EXPECT_EQ(L"a", result[0]);
432
433 result = fxcrt::Split(WideString(L","), L',');
434 ASSERT_EQ(2u, result.size());
435 EXPECT_EQ(L"", result[0]);
436 EXPECT_EQ(L"", result[1]);
437
438 result = fxcrt::Split(WideString(L"a,"), L',');
439 ASSERT_EQ(2u, result.size());
440 EXPECT_EQ(L"a", result[0]);
441 EXPECT_EQ(L"", result[1]);
442
443 result = fxcrt::Split(WideString(L",b"), L',');
444 ASSERT_EQ(2u, result.size());
445 EXPECT_EQ(L"", result[0]);
446 EXPECT_EQ(L"b", result[1]);
447
448 result = fxcrt::Split(WideString(L"a,b"), L',');
449 ASSERT_EQ(2u, result.size());
450 EXPECT_EQ(L"a", result[0]);
451 EXPECT_EQ(L"b", result[1]);
452
453 result = fxcrt::Split(WideString(L"a,b,"), L',');
454 ASSERT_EQ(3u, result.size());
455 EXPECT_EQ(L"a", result[0]);
456 EXPECT_EQ(L"b", result[1]);
457 EXPECT_EQ(L"", result[2]);
458
459 result = fxcrt::Split(WideString(L"a,,"), L',');
460 ASSERT_EQ(3u, result.size());
461 EXPECT_EQ(L"a", result[0]);
462 EXPECT_EQ(L"", result[1]);
463 EXPECT_EQ(L"", result[2]);
464
465 result = fxcrt::Split(WideString(L",,a"), L',');
466 ASSERT_EQ(3u, result.size());
467 EXPECT_EQ(L"", result[0]);
468 EXPECT_EQ(L"", result[1]);
469 EXPECT_EQ(L"a", result[2]);
470 }
471
TEST(fxstring,SplitWideStringView)472 TEST(fxstring, SplitWideStringView) {
473 std::vector<WideStringView> result;
474 result = fxcrt::Split(WideStringView(L""), L',');
475 ASSERT_EQ(1u, result.size());
476 EXPECT_EQ(L"", result[0]);
477
478 result = fxcrt::Split(WideStringView(L"a"), L',');
479 ASSERT_EQ(1u, result.size());
480 EXPECT_EQ(L"a", result[0]);
481
482 result = fxcrt::Split(WideStringView(L","), L',');
483 ASSERT_EQ(2u, result.size());
484 EXPECT_EQ(L"", result[0]);
485 EXPECT_EQ(L"", result[1]);
486
487 result = fxcrt::Split(WideStringView(L"a,"), L',');
488 ASSERT_EQ(2u, result.size());
489 EXPECT_EQ(L"a", result[0]);
490 EXPECT_EQ(L"", result[1]);
491
492 result = fxcrt::Split(WideStringView(L",b"), L',');
493 ASSERT_EQ(2u, result.size());
494 EXPECT_EQ(L"", result[0]);
495 EXPECT_EQ(L"b", result[1]);
496
497 result = fxcrt::Split(WideStringView(L"a,b"), L',');
498 ASSERT_EQ(2u, result.size());
499 EXPECT_EQ(L"a", result[0]);
500 EXPECT_EQ(L"b", result[1]);
501
502 result = fxcrt::Split(WideStringView(L"a,b,"), L',');
503 ASSERT_EQ(3u, result.size());
504 EXPECT_EQ(L"a", result[0]);
505 EXPECT_EQ(L"b", result[1]);
506 EXPECT_EQ(L"", result[2]);
507
508 result = fxcrt::Split(WideStringView(L"a,,"), L',');
509 ASSERT_EQ(3u, result.size());
510 EXPECT_EQ(L"a", result[0]);
511 EXPECT_EQ(L"", result[1]);
512 EXPECT_EQ(L"", result[2]);
513
514 result = fxcrt::Split(WideStringView(L",,a"), L',');
515 ASSERT_EQ(3u, result.size());
516 EXPECT_EQ(L"", result[0]);
517 EXPECT_EQ(L"", result[1]);
518 EXPECT_EQ(L"a", result[2]);
519 }
520
TEST(fxstring,ByteStringSplitEfficiency)521 TEST(fxstring, ByteStringSplitEfficiency) {
522 std::vector<char> commas(50000, ',');
523 ByteString input(commas.data(), commas.size());
524 std::vector<ByteString> result;
525 result = fxcrt::Split(input, ',');
526 ASSERT_EQ(commas.size() + 1, result.size());
527 EXPECT_EQ("", result.front());
528 EXPECT_EQ("", result.back());
529 }
530
TEST(fxstring,ByteStringViewSplitEfficiency)531 TEST(fxstring, ByteStringViewSplitEfficiency) {
532 std::vector<char> commas(50000, ',');
533 ByteStringView input(commas.data(), commas.size());
534 std::vector<ByteStringView> result;
535 result = fxcrt::Split(input, ',');
536 ASSERT_EQ(commas.size() + 1, result.size());
537 EXPECT_EQ("", result.front());
538 EXPECT_EQ("", result.back());
539 }
540
TEST(fxstring,WideStringSplitEfficiency)541 TEST(fxstring, WideStringSplitEfficiency) {
542 std::vector<wchar_t> commas(50000, L',');
543 WideString input(commas.data(), commas.size());
544 std::vector<WideString> result;
545 result = fxcrt::Split(input, ',');
546 ASSERT_EQ(commas.size() + 1, result.size());
547 EXPECT_EQ(L"", result.front());
548 EXPECT_EQ(L"", result.back());
549 }
550
TEST(fxstring,WideStringViewSplitEfficiency)551 TEST(fxstring, WideStringViewSplitEfficiency) {
552 std::vector<wchar_t> commas(50000, L',');
553 WideStringView input(commas.data(), commas.size());
554 std::vector<WideStringView> result;
555 result = fxcrt::Split(input, ',');
556 ASSERT_EQ(commas.size() + 1, result.size());
557 EXPECT_EQ(L"", result.front());
558 EXPECT_EQ(L"", result.back());
559 }
560