Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
fx_string_unittest.cpp
Go to the documentation of this file.
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
13TEST(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
34TEST(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)
45TEST(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
55TEST(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
78TEST(fxstring, WideStringToFloat) {
79 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L""));
80 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"0"));
81 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"0.0"));
82 EXPECT_FLOAT_EQ(0.0f, StringToFloat(L"-0.0"));
83
84 EXPECT_FLOAT_EQ(0.25f, StringToFloat(L"0.25"));
85 EXPECT_FLOAT_EQ(-0.25f, StringToFloat(L"-0.25"));
86
87 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L"100"));
88 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L"100.0"));
89 EXPECT_FLOAT_EQ(100.0f, StringToFloat(L" 100.0"));
90 EXPECT_FLOAT_EQ(-100.0f, StringToFloat(L"-100.0000"));
91
92 EXPECT_FLOAT_EQ(3.402823e+38f,
93 StringToFloat(L"340282300000000000000000000000000000000"));
94 EXPECT_FLOAT_EQ(-3.402823e+38f,
95 StringToFloat(L"-340282300000000000000000000000000000000"));
96
97 EXPECT_FLOAT_EQ(1.000000119f, StringToFloat(L"1.000000119"));
98 EXPECT_FLOAT_EQ(1.999999881f, StringToFloat(L"1.999999881"));
99}
100
101TEST(fxstring, ByteStringToDouble) {
102 EXPECT_FLOAT_EQ(0.0, StringToDouble(""));
103 EXPECT_FLOAT_EQ(0.0, StringToDouble("0"));
104 EXPECT_FLOAT_EQ(0.0, StringToDouble("0.0"));
105 EXPECT_FLOAT_EQ(0.0, StringToDouble("-0.0"));
106
107 EXPECT_FLOAT_EQ(0.25, StringToDouble("0.25"));
108 EXPECT_FLOAT_EQ(-0.25, StringToDouble("-0.25"));
109
110 EXPECT_FLOAT_EQ(100.0, StringToDouble("100"));
111 EXPECT_FLOAT_EQ(100.0, StringToDouble("100.0"));
112 EXPECT_FLOAT_EQ(100.0, StringToDouble(" 100.0"));
113 EXPECT_FLOAT_EQ(-100.0, StringToDouble("-100.0000"));
114
115 EXPECT_FLOAT_EQ(3.402823e+38,
116 StringToDouble("340282300000000000000000000000000000000"));
117 EXPECT_FLOAT_EQ(-3.402823e+38,
118 StringToDouble("-340282300000000000000000000000000000000"));
119
120 EXPECT_FLOAT_EQ(1.000000119, StringToDouble("1.000000119"));
121 EXPECT_FLOAT_EQ(1.999999881, StringToDouble("1.999999881"));
122}
123
124TEST(fxstring, WideStringToDouble) {
125 EXPECT_FLOAT_EQ(0.0, StringToDouble(L""));
126 EXPECT_FLOAT_EQ(0.0, StringToDouble(L"0"));
127 EXPECT_FLOAT_EQ(0.0, StringToDouble(L"0.0"));
128 EXPECT_FLOAT_EQ(0.0, StringToDouble(L"-0.0"));
129
130 EXPECT_FLOAT_EQ(0.25, StringToDouble(L"0.25"));
131 EXPECT_FLOAT_EQ(-0.25, StringToDouble(L"-0.25"));
132
133 EXPECT_FLOAT_EQ(100.0, StringToDouble(L"100"));
134 EXPECT_FLOAT_EQ(100.0, StringToDouble(L"100.0"));
135 EXPECT_FLOAT_EQ(100.0, StringToDouble(L" 100.0"));
136 EXPECT_FLOAT_EQ(-100.0, StringToDouble(L"-100.0000"));
137
138 EXPECT_FLOAT_EQ(3.402823e+38,
139 StringToDouble(L"340282300000000000000000000000000000000"));
140 EXPECT_FLOAT_EQ(-3.402823e+38,
141 StringToDouble(L"-340282300000000000000000000000000000000"));
142
143 EXPECT_FLOAT_EQ(1.000000119, StringToDouble(L"1.000000119"));
144 EXPECT_FLOAT_EQ(1.999999881, StringToDouble(L"1.999999881"));
145}
146
147TEST(fxstring, SplitByteString) {
148 std::vector<ByteString> result;
149 result = fxcrt::Split(ByteString(""), ',');
150 ASSERT_EQ(1u, result.size());
151 EXPECT_EQ("", result[0]);
152
153 result = fxcrt::Split(ByteString("a"), ',');
154 ASSERT_EQ(1u, result.size());
155 EXPECT_EQ("a", result[0]);
156
157 result = fxcrt::Split(ByteString(","), ',');
158 ASSERT_EQ(2u, result.size());
159 EXPECT_EQ("", result[0]);
160 EXPECT_EQ("", result[1]);
161
162 result = fxcrt::Split(ByteString("a,"), ',');
163 ASSERT_EQ(2u, result.size());
164 EXPECT_EQ("a", result[0]);
165 EXPECT_EQ("", result[1]);
166
167 result = fxcrt::Split(ByteString(",b"), ',');
168 ASSERT_EQ(2u, result.size());
169 EXPECT_EQ("", result[0]);
170 EXPECT_EQ("b", result[1]);
171
172 result = fxcrt::Split(ByteString("a,b"), ',');
173 ASSERT_EQ(2u, result.size());
174 EXPECT_EQ("a", result[0]);
175 EXPECT_EQ("b", result[1]);
176
177 result = fxcrt::Split(ByteString("a,b,"), ',');
178 ASSERT_EQ(3u, result.size());
179 EXPECT_EQ("a", result[0]);
180 EXPECT_EQ("b", result[1]);
181 EXPECT_EQ("", result[2]);
182
183 result = fxcrt::Split(ByteString("a,,"), ',');
184 ASSERT_EQ(3u, result.size());
185 EXPECT_EQ("a", result[0]);
186 EXPECT_EQ("", result[1]);
187 EXPECT_EQ("", result[2]);
188
189 result = fxcrt::Split(ByteString(",,a"), ',');
190 ASSERT_EQ(3u, result.size());
191 EXPECT_EQ("", result[0]);
192 EXPECT_EQ("", result[1]);
193 EXPECT_EQ("a", result[2]);
194}
195
196TEST(fxstring, SplitByteStringView) {
197 std::vector<ByteStringView> result;
198 result = fxcrt::Split(ByteStringView(""), ',');
199 ASSERT_EQ(1u, result.size());
200 EXPECT_EQ("", result[0]);
201
202 result = fxcrt::Split(ByteStringView("a"), ',');
203 ASSERT_EQ(1u, result.size());
204 EXPECT_EQ("a", result[0]);
205
206 result = fxcrt::Split(ByteStringView(","), ',');
207 ASSERT_EQ(2u, result.size());
208 EXPECT_EQ("", result[0]);
209 EXPECT_EQ("", result[1]);
210
211 result = fxcrt::Split(ByteStringView("a,"), ',');
212 ASSERT_EQ(2u, result.size());
213 EXPECT_EQ("a", result[0]);
214 EXPECT_EQ("", result[1]);
215
216 result = fxcrt::Split(ByteStringView(",b"), ',');
217 ASSERT_EQ(2u, result.size());
218 EXPECT_EQ("", result[0]);
219 EXPECT_EQ("b", result[1]);
220
221 result = fxcrt::Split(ByteStringView("a,b"), ',');
222 ASSERT_EQ(2u, result.size());
223 EXPECT_EQ("a", result[0]);
224 EXPECT_EQ("b", result[1]);
225
226 result = fxcrt::Split(ByteStringView("a,b,"), ',');
227 ASSERT_EQ(3u, result.size());
228 EXPECT_EQ("a", result[0]);
229 EXPECT_EQ("b", result[1]);
230 EXPECT_EQ("", result[2]);
231
232 result = fxcrt::Split(ByteStringView("a,,"), ',');
233 ASSERT_EQ(3u, result.size());
234 EXPECT_EQ("a", result[0]);
235 EXPECT_EQ("", result[1]);
236 EXPECT_EQ("", result[2]);
237
238 result = fxcrt::Split(ByteStringView(",,a"), ',');
239 ASSERT_EQ(3u, result.size());
240 EXPECT_EQ("", result[0]);
241 EXPECT_EQ("", result[1]);
242 EXPECT_EQ("a", result[2]);
243}
244
245TEST(fxstring, SplitWideString) {
246 std::vector<WideString> result;
247 result = fxcrt::Split(WideString(L""), L',');
248 ASSERT_EQ(1u, result.size());
249 EXPECT_EQ(L"", result[0]);
250
251 result = fxcrt::Split(WideString(L"a"), L',');
252 ASSERT_EQ(1u, result.size());
253 EXPECT_EQ(L"a", result[0]);
254
255 result = fxcrt::Split(WideString(L","), L',');
256 ASSERT_EQ(2u, result.size());
257 EXPECT_EQ(L"", result[0]);
258 EXPECT_EQ(L"", result[1]);
259
260 result = fxcrt::Split(WideString(L"a,"), L',');
261 ASSERT_EQ(2u, result.size());
262 EXPECT_EQ(L"a", result[0]);
263 EXPECT_EQ(L"", result[1]);
264
265 result = fxcrt::Split(WideString(L",b"), L',');
266 ASSERT_EQ(2u, result.size());
267 EXPECT_EQ(L"", result[0]);
268 EXPECT_EQ(L"b", result[1]);
269
270 result = fxcrt::Split(WideString(L"a,b"), L',');
271 ASSERT_EQ(2u, result.size());
272 EXPECT_EQ(L"a", result[0]);
273 EXPECT_EQ(L"b", result[1]);
274
275 result = fxcrt::Split(WideString(L"a,b,"), L',');
276 ASSERT_EQ(3u, result.size());
277 EXPECT_EQ(L"a", result[0]);
278 EXPECT_EQ(L"b", result[1]);
279 EXPECT_EQ(L"", result[2]);
280
281 result = fxcrt::Split(WideString(L"a,,"), L',');
282 ASSERT_EQ(3u, result.size());
283 EXPECT_EQ(L"a", result[0]);
284 EXPECT_EQ(L"", result[1]);
285 EXPECT_EQ(L"", result[2]);
286
287 result = fxcrt::Split(WideString(L",,a"), L',');
288 ASSERT_EQ(3u, result.size());
289 EXPECT_EQ(L"", result[0]);
290 EXPECT_EQ(L"", result[1]);
291 EXPECT_EQ(L"a", result[2]);
292}
293
294TEST(fxstring, SplitWideStringView) {
295 std::vector<WideStringView> result;
296 result = fxcrt::Split(WideStringView(L""), L',');
297 ASSERT_EQ(1u, result.size());
298 EXPECT_EQ(L"", result[0]);
299
300 result = fxcrt::Split(WideStringView(L"a"), L',');
301 ASSERT_EQ(1u, result.size());
302 EXPECT_EQ(L"a", result[0]);
303
304 result = fxcrt::Split(WideStringView(L","), L',');
305 ASSERT_EQ(2u, result.size());
306 EXPECT_EQ(L"", result[0]);
307 EXPECT_EQ(L"", result[1]);
308
309 result = fxcrt::Split(WideStringView(L"a,"), L',');
310 ASSERT_EQ(2u, result.size());
311 EXPECT_EQ(L"a", result[0]);
312 EXPECT_EQ(L"", result[1]);
313
314 result = fxcrt::Split(WideStringView(L",b"), L',');
315 ASSERT_EQ(2u, result.size());
316 EXPECT_EQ(L"", result[0]);
317 EXPECT_EQ(L"b", result[1]);
318
319 result = fxcrt::Split(WideStringView(L"a,b"), L',');
320 ASSERT_EQ(2u, result.size());
321 EXPECT_EQ(L"a", result[0]);
322 EXPECT_EQ(L"b", result[1]);
323
324 result = fxcrt::Split(WideStringView(L"a,b,"), L',');
325 ASSERT_EQ(3u, result.size());
326 EXPECT_EQ(L"a", result[0]);
327 EXPECT_EQ(L"b", result[1]);
328 EXPECT_EQ(L"", result[2]);
329
330 result = fxcrt::Split(WideStringView(L"a,,"), L',');
331 ASSERT_EQ(3u, result.size());
332 EXPECT_EQ(L"a", result[0]);
333 EXPECT_EQ(L"", result[1]);
334 EXPECT_EQ(L"", result[2]);
335
336 result = fxcrt::Split(WideStringView(L",,a"), L',');
337 ASSERT_EQ(3u, result.size());
338 EXPECT_EQ(L"", result[0]);
339 EXPECT_EQ(L"", result[1]);
340 EXPECT_EQ(L"a", result[2]);
341}
342
343TEST(fxstring, ByteStringSplitEfficiency) {
344 std::vector<char> commas(50000, ',');
345 auto input = ByteString(ByteStringView(commas));
346 std::vector<ByteString> result;
347 result = fxcrt::Split(input, ',');
348 ASSERT_EQ(commas.size() + 1, result.size());
349 EXPECT_EQ("", result.front());
350 EXPECT_EQ("", result.back());
351}
352
353TEST(fxstring, ByteStringViewSplitEfficiency) {
354 std::vector<char> commas(50000, ',');
355 ByteStringView input(commas);
356 std::vector<ByteStringView> result;
357 result = fxcrt::Split(input, ',');
358 ASSERT_EQ(commas.size() + 1, result.size());
359 EXPECT_EQ("", result.front());
360 EXPECT_EQ("", result.back());
361}
362
363TEST(fxstring, WideStringSplitEfficiency) {
364 std::vector<wchar_t> commas(50000, L',');
365 auto input = WideString(WideStringView(commas));
366 std::vector<WideString> result;
367 result = fxcrt::Split(input, ',');
368 ASSERT_EQ(commas.size() + 1, result.size());
369 EXPECT_EQ(L"", result.front());
370 EXPECT_EQ(L"", result.back());
371}
372
373TEST(fxstring, WideStringViewSplitEfficiency) {
374 std::vector<wchar_t> commas(50000, L',');
375 WideStringView input(commas);
376 std::vector<WideStringView> result;
377 result = fxcrt::Split(input, ',');
378 ASSERT_EQ(commas.size() + 1, result.size());
379 EXPECT_EQ(L"", result.front());
380 EXPECT_EQ(L"", result.back());
381}
ByteString
fxcrt::ByteString ByteString
Definition bytestring.h:180
fxcrt::ByteString::ByteString
ByteString(const char *ptr)
Definition bytestring.cpp:103
fxcrt::WideString::WideString
WideString(const wchar_t *ptr)
Definition widestring.cpp:407
TEST
TEST(FXCRYPT, MD5GenerateEmtpyData)
Definition fx_crypt_unittest.cpp:50
ByteStringView
fxcrt::ByteStringView ByteStringView
Definition string_view_template.h:325
WideStringView
fxcrt::WideStringView WideStringView
Definition string_view_template.h:326
WideString
fxcrt::WideString WideString
Definition widestring.h:207