bloaty/third_party/abseil-cpp/absl/flags/marshalling_test.cc
Go to the documentation of this file.
1 //
2 // Copyright 2019 The Abseil Authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // https://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 
16 #include "absl/flags/marshalling.h"
17 
18 #include <stdint.h>
19 
20 #include <cmath>
21 #include <limits>
22 #include <string>
23 #include <vector>
24 
25 #include "gtest/gtest.h"
26 
27 namespace {
28 
29 TEST(MarshallingTest, TestBoolParsing) {
30  std::string err;
31  bool value;
32 
33  // True values.
34  EXPECT_TRUE(absl::ParseFlag("True", &value, &err));
35  EXPECT_TRUE(value);
36  EXPECT_TRUE(absl::ParseFlag("true", &value, &err));
37  EXPECT_TRUE(value);
38  EXPECT_TRUE(absl::ParseFlag("TRUE", &value, &err));
39  EXPECT_TRUE(value);
40 
41  EXPECT_TRUE(absl::ParseFlag("Yes", &value, &err));
42  EXPECT_TRUE(value);
43  EXPECT_TRUE(absl::ParseFlag("yes", &value, &err));
44  EXPECT_TRUE(value);
45  EXPECT_TRUE(absl::ParseFlag("YES", &value, &err));
46  EXPECT_TRUE(value);
47 
48  EXPECT_TRUE(absl::ParseFlag("t", &value, &err));
49  EXPECT_TRUE(value);
50  EXPECT_TRUE(absl::ParseFlag("T", &value, &err));
51  EXPECT_TRUE(value);
52 
53  EXPECT_TRUE(absl::ParseFlag("y", &value, &err));
54  EXPECT_TRUE(value);
55  EXPECT_TRUE(absl::ParseFlag("Y", &value, &err));
56  EXPECT_TRUE(value);
57 
58  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
59  EXPECT_TRUE(value);
60 
61  // False values.
62  EXPECT_TRUE(absl::ParseFlag("False", &value, &err));
63  EXPECT_FALSE(value);
64  EXPECT_TRUE(absl::ParseFlag("false", &value, &err));
65  EXPECT_FALSE(value);
66  EXPECT_TRUE(absl::ParseFlag("FALSE", &value, &err));
67  EXPECT_FALSE(value);
68 
69  EXPECT_TRUE(absl::ParseFlag("No", &value, &err));
70  EXPECT_FALSE(value);
71  EXPECT_TRUE(absl::ParseFlag("no", &value, &err));
72  EXPECT_FALSE(value);
73  EXPECT_TRUE(absl::ParseFlag("NO", &value, &err));
74  EXPECT_FALSE(value);
75 
76  EXPECT_TRUE(absl::ParseFlag("f", &value, &err));
77  EXPECT_FALSE(value);
78  EXPECT_TRUE(absl::ParseFlag("F", &value, &err));
79  EXPECT_FALSE(value);
80 
81  EXPECT_TRUE(absl::ParseFlag("n", &value, &err));
82  EXPECT_FALSE(value);
83  EXPECT_TRUE(absl::ParseFlag("N", &value, &err));
84  EXPECT_FALSE(value);
85 
86  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
87  EXPECT_FALSE(value);
88 
89  // Whitespace handling.
90  EXPECT_TRUE(absl::ParseFlag(" true", &value, &err));
91  EXPECT_TRUE(value);
92  EXPECT_TRUE(absl::ParseFlag("true ", &value, &err));
93  EXPECT_TRUE(value);
94  EXPECT_TRUE(absl::ParseFlag(" true ", &value, &err));
95  EXPECT_TRUE(value);
96 
97  // Invalid input.
98  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
99  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
100  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
101  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
102  EXPECT_FALSE(absl::ParseFlag("2", &value, &err));
103  EXPECT_FALSE(absl::ParseFlag("11", &value, &err));
104  EXPECT_FALSE(absl::ParseFlag("tt", &value, &err));
105 }
106 
107 // --------------------------------------------------------------------
108 
109 TEST(MarshallingTest, TestInt16Parsing) {
110  std::string err;
111  int16_t value;
112 
113  // Decimal values.
114  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
115  EXPECT_EQ(value, 1);
116  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
117  EXPECT_EQ(value, 0);
118  EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
119  EXPECT_EQ(value, -1);
120  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
121  EXPECT_EQ(value, 123);
122  EXPECT_TRUE(absl::ParseFlag("-18765", &value, &err));
123  EXPECT_EQ(value, -18765);
124  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
125  EXPECT_EQ(value, 3);
126 
127  // Leading zero values.
128  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
129  EXPECT_EQ(value, 1);
130  EXPECT_TRUE(absl::ParseFlag("-001", &value, &err));
131  EXPECT_EQ(value, -1);
132  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
133  EXPECT_EQ(value, 100);
134 
135  // Hex values.
136  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
137  EXPECT_EQ(value, 16);
138  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
139  EXPECT_EQ(value, 564);
140  // TODO(rogeeff): fix below validations
141  EXPECT_FALSE(absl::ParseFlag("-0x7FFD", &value, &err));
142  EXPECT_NE(value, -3);
143  EXPECT_FALSE(absl::ParseFlag("+0x31", &value, &err));
144  EXPECT_NE(value, 49);
145 
146  // Whitespace handling
147  EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err));
148  EXPECT_EQ(value, 10);
149  EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err));
150  EXPECT_EQ(value, 11);
151  EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err));
152  EXPECT_EQ(value, 12);
153  EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err));
154  EXPECT_EQ(value, 34);
155 
156  // Invalid values.
157  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
158  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
159  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
160  EXPECT_FALSE(absl::ParseFlag("40000", &value, &err));
161  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
162  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
163  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
164  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
165  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
166 }
167 
168 // --------------------------------------------------------------------
169 
170 TEST(MarshallingTest, TestUint16Parsing) {
171  std::string err;
172  uint16_t value;
173 
174  // Decimal values.
175  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
176  EXPECT_EQ(value, 1);
177  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
178  EXPECT_EQ(value, 0);
179  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
180  EXPECT_EQ(value, 123);
181  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
182  EXPECT_EQ(value, 3);
183 
184  // Leading zero values.
185  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
186  EXPECT_EQ(value, 1);
187  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
188  EXPECT_EQ(value, 1);
189  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
190  EXPECT_EQ(value, 100);
191 
192  // Hex values.
193  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
194  EXPECT_EQ(value, 16);
195  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
196  EXPECT_EQ(value, 564);
197  // TODO(rogeeff): fix below validations
198  EXPECT_FALSE(absl::ParseFlag("+0x31", &value, &err));
199  EXPECT_NE(value, 49);
200 
201  // Whitespace handling
202  EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err));
203  EXPECT_EQ(value, 10);
204  EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err));
205  EXPECT_EQ(value, 11);
206  EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err));
207  EXPECT_EQ(value, 12);
208  EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err));
209  EXPECT_EQ(value, 34);
210 
211  // Invalid values.
212  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
213  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
214  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
215  EXPECT_FALSE(absl::ParseFlag("70000", &value, &err));
216  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
217  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
218  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
219  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
220  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
221  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
222 }
223 
224 // --------------------------------------------------------------------
225 
226 TEST(MarshallingTest, TestInt32Parsing) {
227  std::string err;
228  int32_t value;
229 
230  // Decimal values.
231  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
232  EXPECT_EQ(value, 1);
233  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
234  EXPECT_EQ(value, 0);
235  EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
236  EXPECT_EQ(value, -1);
237  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
238  EXPECT_EQ(value, 123);
239  EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
240  EXPECT_EQ(value, -98765);
241  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
242  EXPECT_EQ(value, 3);
243 
244  // Leading zero values.
245  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
246  EXPECT_EQ(value, 1);
247  EXPECT_TRUE(absl::ParseFlag("-001", &value, &err));
248  EXPECT_EQ(value, -1);
249  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
250  EXPECT_EQ(value, 100);
251 
252  // Hex values.
253  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
254  EXPECT_EQ(value, 16);
255  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
256  EXPECT_EQ(value, 564);
257  // TODO(rogeeff): fix below validations
258  EXPECT_FALSE(absl::ParseFlag("-0x7FFFFFFD", &value, &err));
259  EXPECT_NE(value, -3);
260  EXPECT_FALSE(absl::ParseFlag("+0x31", &value, &err));
261  EXPECT_NE(value, 49);
262 
263  // Whitespace handling
264  EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err));
265  EXPECT_EQ(value, 10);
266  EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err));
267  EXPECT_EQ(value, 11);
268  EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err));
269  EXPECT_EQ(value, 12);
270  EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err));
271  EXPECT_EQ(value, 34);
272 
273  // Invalid values.
274  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
275  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
276  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
277  EXPECT_FALSE(absl::ParseFlag("70000000000", &value, &err));
278  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
279  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
280  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
281  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
282  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
283 }
284 
285 // --------------------------------------------------------------------
286 
287 TEST(MarshallingTest, TestUint32Parsing) {
288  std::string err;
289  uint32_t value;
290 
291  // Decimal values.
292  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
293  EXPECT_EQ(value, 1);
294  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
295  EXPECT_EQ(value, 0);
296  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
297  EXPECT_EQ(value, 123);
298  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
299  EXPECT_EQ(value, 3);
300 
301  // Leading zero values.
302  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
303  EXPECT_EQ(value, 1);
304  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
305  EXPECT_EQ(value, 100);
306 
307  // Hex values.
308  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
309  EXPECT_EQ(value, 16);
310  EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
311  EXPECT_EQ(value, 564);
312  EXPECT_TRUE(absl::ParseFlag("0xFFFFFFFD", &value, &err));
313  EXPECT_EQ(value, 4294967293);
314  // TODO(rogeeff): fix below validations
315  EXPECT_FALSE(absl::ParseFlag("+0x31", &value, &err));
316  EXPECT_NE(value, 49);
317 
318  // Whitespace handling
319  EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err));
320  EXPECT_EQ(value, 10);
321  EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err));
322  EXPECT_EQ(value, 11);
323  EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err));
324  EXPECT_EQ(value, 12);
325  EXPECT_TRUE(absl::ParseFlag(" 0x22 ", &value, &err));
326  EXPECT_EQ(value, 34);
327 
328  // Invalid values.
329  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
330  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
331  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
332  EXPECT_FALSE(absl::ParseFlag("140000000000", &value, &err));
333  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
334  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
335  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
336  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
337  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
338  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
339 }
340 
341 // --------------------------------------------------------------------
342 
343 TEST(MarshallingTest, TestInt64Parsing) {
344  std::string err;
345  int64_t value;
346 
347  // Decimal values.
348  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
349  EXPECT_EQ(value, 1);
350  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
351  EXPECT_EQ(value, 0);
352  EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
353  EXPECT_EQ(value, -1);
354  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
355  EXPECT_EQ(value, 123);
356  EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
357  EXPECT_EQ(value, -98765);
358  EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
359  EXPECT_EQ(value, 3);
360 
361  // Leading zero values.
362  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
363  EXPECT_EQ(value, 1);
364  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
365  EXPECT_EQ(value, 1);
366  EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
367  EXPECT_EQ(value, 100);
368 
369  // Hex values.
370  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
371  EXPECT_EQ(value, 16);
372  EXPECT_TRUE(absl::ParseFlag("0XFFFAAABBBCCCDDD", &value, &err));
373  EXPECT_EQ(value, 1152827684197027293);
374  // TODO(rogeeff): fix below validation
375  EXPECT_FALSE(absl::ParseFlag("-0x7FFFFFFFFFFFFFFE", &value, &err));
376  EXPECT_NE(value, -2);
377  EXPECT_FALSE(absl::ParseFlag("+0x31", &value, &err));
378  EXPECT_NE(value, 49);
379 
380  // Whitespace handling
381  EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err));
382  EXPECT_EQ(value, 10);
383  EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err));
384  EXPECT_EQ(value, 11);
385  EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err));
386  EXPECT_EQ(value, 12);
387  EXPECT_TRUE(absl::ParseFlag(" 0x7F ", &value, &err));
388  EXPECT_EQ(value, 127);
389 
390  // Invalid values.
391  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
392  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
393  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
394  EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err));
395  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
396  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
397  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
398  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
399  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
400 }
401 
402 // --------------------------------------------------------------------
403 
404 TEST(MarshallingTest, TestUInt64Parsing) {
405  std::string err;
406  uint64_t value;
407 
408  // Decimal values.
409  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
410  EXPECT_EQ(value, 1);
411  EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
412  EXPECT_EQ(value, 0);
413  EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
414  EXPECT_EQ(value, 123);
415  EXPECT_TRUE(absl::ParseFlag("+13", &value, &err));
416  EXPECT_EQ(value, 13);
417 
418  // Leading zero values.
419  EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
420  EXPECT_EQ(value, 1);
421  EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
422  EXPECT_EQ(value, 1);
423  EXPECT_TRUE(absl::ParseFlag("0000300", &value, &err));
424  EXPECT_EQ(value, 300);
425 
426  // Hex values.
427  EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
428  EXPECT_EQ(value, 16);
429  EXPECT_TRUE(absl::ParseFlag("0XFFFF", &value, &err));
430  EXPECT_EQ(value, 65535);
431  // TODO(rogeeff): fix below validation
432  EXPECT_FALSE(absl::ParseFlag("+0x31", &value, &err));
433  EXPECT_NE(value, 49);
434 
435  // Whitespace handling
436  EXPECT_TRUE(absl::ParseFlag("10 ", &value, &err));
437  EXPECT_EQ(value, 10);
438  EXPECT_TRUE(absl::ParseFlag(" 11", &value, &err));
439  EXPECT_EQ(value, 11);
440  EXPECT_TRUE(absl::ParseFlag(" 012 ", &value, &err));
441  EXPECT_EQ(value, 12);
442 
443  // Invalid values.
444  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
445  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
446  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
447  EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err));
448  EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
449  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
450  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
451  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
452  EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
453  EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
454 }
455 
456 // --------------------------------------------------------------------
457 
458 TEST(MarshallingTest, TestFloatParsing) {
459  std::string err;
460  float value;
461 
462  // Ordinary values.
463  EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err));
464  EXPECT_FLOAT_EQ(value, 1.3f);
465  EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err));
466  EXPECT_DOUBLE_EQ(value, -0.1f);
467  EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err));
468  EXPECT_DOUBLE_EQ(value, 0.01f);
469 
470  // Scientific values.
471  EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err));
472  EXPECT_DOUBLE_EQ(value, 1.2e3f);
473  EXPECT_TRUE(absl::ParseFlag("9.8765402e-37", &value, &err));
474  EXPECT_DOUBLE_EQ(value, 9.8765402e-37f);
475  EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err));
476  EXPECT_DOUBLE_EQ(value, 0.11e+3f);
477  EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err));
478  EXPECT_DOUBLE_EQ(value, 0.f);
479  EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err));
480  EXPECT_TRUE(std::isinf(value));
481 
482  // Leading zero values.
483  EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err));
484  EXPECT_DOUBLE_EQ(value, 1.6f);
485  EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err));
486  EXPECT_DOUBLE_EQ(value, 0.0001f);
487 
488  // Trailing zero values.
489  EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err));
490  EXPECT_DOUBLE_EQ(value, -5.1f);
491 
492  // Exceptional values.
493  EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err));
494  EXPECT_TRUE(std::isnan(value));
495  EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err));
496  EXPECT_TRUE(std::isinf(value));
497 
498  // Hex values
499  EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err));
500  EXPECT_DOUBLE_EQ(value, 66096.f);
501  EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err));
502  EXPECT_NEAR(value, -60.4092f, 5e-5f);
503  EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err));
504  EXPECT_NEAR(value, 1.01328e-05f, 5e-11f);
505  EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err));
506  EXPECT_NEAR(value, 0.0078125f, 5e-8f);
507 
508  // Whitespace handling
509  EXPECT_TRUE(absl::ParseFlag("10.1 ", &value, &err));
510  EXPECT_DOUBLE_EQ(value, 10.1f);
511  EXPECT_TRUE(absl::ParseFlag(" 2.34", &value, &err));
512  EXPECT_DOUBLE_EQ(value, 2.34f);
513  EXPECT_TRUE(absl::ParseFlag(" 5.7 ", &value, &err));
514  EXPECT_DOUBLE_EQ(value, 5.7f);
515  EXPECT_TRUE(absl::ParseFlag(" -0xE0.F3p01 ", &value, &err));
516  EXPECT_NEAR(value, -449.8984375f, 5e-8f);
517 
518  // Invalid values.
519  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
520  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
521  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
522  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
523  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
524  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
525  EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err));
526  EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err));
527  // TODO(rogeeff): below assertion should fail
528  EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err));
529 }
530 
531 // --------------------------------------------------------------------
532 
533 TEST(MarshallingTest, TestDoubleParsing) {
534  std::string err;
535  double value;
536 
537  // Ordinary values.
538  EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err));
539  EXPECT_DOUBLE_EQ(value, 1.3);
540  EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err));
541  EXPECT_DOUBLE_EQ(value, -0.1);
542  EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err));
543  EXPECT_DOUBLE_EQ(value, 0.01);
544 
545  // Scientific values.
546  EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err));
547  EXPECT_DOUBLE_EQ(value, 1.2e3);
548  EXPECT_TRUE(absl::ParseFlag("9.00000002e-123", &value, &err));
549  EXPECT_DOUBLE_EQ(value, 9.00000002e-123);
550  EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err));
551  EXPECT_DOUBLE_EQ(value, 0.11e+3);
552  EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err));
553  EXPECT_DOUBLE_EQ(value, 0);
554  EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err));
555  EXPECT_TRUE(std::isinf(value));
556 
557  // Leading zero values.
558  EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err));
559  EXPECT_DOUBLE_EQ(value, 1.6);
560  EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err));
561  EXPECT_DOUBLE_EQ(value, 0.0001);
562 
563  // Trailing zero values.
564  EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err));
565  EXPECT_DOUBLE_EQ(value, -5.1);
566 
567  // Exceptional values.
568  EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err));
569  EXPECT_TRUE(std::isnan(value));
570  EXPECT_TRUE(absl::ParseFlag("nan", &value, &err));
571  EXPECT_TRUE(std::isnan(value));
572  EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err));
573  EXPECT_TRUE(std::isinf(value));
574  EXPECT_TRUE(absl::ParseFlag("inf", &value, &err));
575  EXPECT_TRUE(std::isinf(value));
576 
577  // Hex values
578  EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err));
579  EXPECT_DOUBLE_EQ(value, 66096);
580  EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err));
581  EXPECT_NEAR(value, -60.4092, 5e-5);
582  EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err));
583  EXPECT_NEAR(value, 1.01328e-05, 5e-11);
584  EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err));
585  EXPECT_NEAR(value, 0.0078125, 5e-8);
586 
587  // Whitespace handling
588  EXPECT_TRUE(absl::ParseFlag("10.1 ", &value, &err));
589  EXPECT_DOUBLE_EQ(value, 10.1);
590  EXPECT_TRUE(absl::ParseFlag(" 2.34", &value, &err));
591  EXPECT_DOUBLE_EQ(value, 2.34);
592  EXPECT_TRUE(absl::ParseFlag(" 5.7 ", &value, &err));
593  EXPECT_DOUBLE_EQ(value, 5.7);
594  EXPECT_TRUE(absl::ParseFlag(" -0xE0.F3p01 ", &value, &err));
595  EXPECT_NEAR(value, -449.8984375, 5e-8);
596 
597  // Invalid values.
598  EXPECT_FALSE(absl::ParseFlag("", &value, &err));
599  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
600  EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
601  EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
602  EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
603  EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
604  EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err));
605  EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err));
606  // TODO(rogeeff): below assertion should fail
607  EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err));
608 }
609 
610 // --------------------------------------------------------------------
611 
612 TEST(MarshallingTest, TestStringParsing) {
613  std::string err;
614  std::string value;
615 
616  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
617  EXPECT_EQ(value, "");
618  EXPECT_TRUE(absl::ParseFlag(" ", &value, &err));
619  EXPECT_EQ(value, " ");
620  EXPECT_TRUE(absl::ParseFlag(" ", &value, &err));
621  EXPECT_EQ(value, " ");
622  EXPECT_TRUE(absl::ParseFlag("\n", &value, &err));
623  EXPECT_EQ(value, "\n");
624  EXPECT_TRUE(absl::ParseFlag("\t", &value, &err));
625  EXPECT_EQ(value, "\t");
626  EXPECT_TRUE(absl::ParseFlag("asdfg", &value, &err));
627  EXPECT_EQ(value, "asdfg");
628  EXPECT_TRUE(absl::ParseFlag("asdf ghjk", &value, &err));
629  EXPECT_EQ(value, "asdf ghjk");
630  EXPECT_TRUE(absl::ParseFlag("a\nb\nc", &value, &err));
631  EXPECT_EQ(value, "a\nb\nc");
632  EXPECT_TRUE(absl::ParseFlag("asd\0fgh", &value, &err));
633  EXPECT_EQ(value, "asd");
634  EXPECT_TRUE(absl::ParseFlag("\\\\", &value, &err));
635  EXPECT_EQ(value, "\\\\");
636 }
637 
638 // --------------------------------------------------------------------
639 
640 TEST(MarshallingTest, TestVectorOfStringParsing) {
641  std::string err;
642  std::vector<std::string> value;
643 
644  EXPECT_TRUE(absl::ParseFlag("", &value, &err));
645  EXPECT_EQ(value, std::vector<std::string>{});
646  EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
647  EXPECT_EQ(value, std::vector<std::string>({"1"}));
648  EXPECT_TRUE(absl::ParseFlag("a,b", &value, &err));
649  EXPECT_EQ(value, std::vector<std::string>({"a", "b"}));
650  EXPECT_TRUE(absl::ParseFlag("a,b,c,", &value, &err));
651  EXPECT_EQ(value, std::vector<std::string>({"a", "b", "c", ""}));
652  EXPECT_TRUE(absl::ParseFlag("a,,", &value, &err));
653  EXPECT_EQ(value, std::vector<std::string>({"a", "", ""}));
654  EXPECT_TRUE(absl::ParseFlag(",", &value, &err));
655  EXPECT_EQ(value, std::vector<std::string>({"", ""}));
656  EXPECT_TRUE(absl::ParseFlag("a, b,c ", &value, &err));
657  EXPECT_EQ(value, std::vector<std::string>({"a", " b", "c "}));
658 }
659 
660 // --------------------------------------------------------------------
661 
662 TEST(MarshallingTest, TestBoolUnparsing) {
663  EXPECT_EQ(absl::UnparseFlag(true), "true");
664  EXPECT_EQ(absl::UnparseFlag(false), "false");
665 }
666 
667 // --------------------------------------------------------------------
668 
669 TEST(MarshallingTest, TestInt16Unparsing) {
670  int16_t value;
671 
672  value = 1;
673  EXPECT_EQ(absl::UnparseFlag(value), "1");
674  value = 0;
675  EXPECT_EQ(absl::UnparseFlag(value), "0");
676  value = -1;
677  EXPECT_EQ(absl::UnparseFlag(value), "-1");
678  value = 9876;
679  EXPECT_EQ(absl::UnparseFlag(value), "9876");
680  value = -987;
681  EXPECT_EQ(absl::UnparseFlag(value), "-987");
682 }
683 
684 // --------------------------------------------------------------------
685 
686 TEST(MarshallingTest, TestUint16Unparsing) {
687  uint16_t value;
688 
689  value = 1;
690  EXPECT_EQ(absl::UnparseFlag(value), "1");
691  value = 0;
692  EXPECT_EQ(absl::UnparseFlag(value), "0");
693  value = 19876;
694  EXPECT_EQ(absl::UnparseFlag(value), "19876");
695 }
696 
697 // --------------------------------------------------------------------
698 
699 TEST(MarshallingTest, TestInt32Unparsing) {
700  int32_t value;
701 
702  value = 1;
703  EXPECT_EQ(absl::UnparseFlag(value), "1");
704  value = 0;
705  EXPECT_EQ(absl::UnparseFlag(value), "0");
706  value = -1;
707  EXPECT_EQ(absl::UnparseFlag(value), "-1");
708  value = 12345;
709  EXPECT_EQ(absl::UnparseFlag(value), "12345");
710  value = -987;
711  EXPECT_EQ(absl::UnparseFlag(value), "-987");
712 }
713 
714 // --------------------------------------------------------------------
715 
716 TEST(MarshallingTest, TestUint32Unparsing) {
717  uint32_t value;
718 
719  value = 1;
720  EXPECT_EQ(absl::UnparseFlag(value), "1");
721  value = 0;
722  EXPECT_EQ(absl::UnparseFlag(value), "0");
723  value = 1234500;
724  EXPECT_EQ(absl::UnparseFlag(value), "1234500");
725 }
726 
727 // --------------------------------------------------------------------
728 
729 TEST(MarshallingTest, TestInt64Unparsing) {
730  int64_t value;
731 
732  value = 1;
733  EXPECT_EQ(absl::UnparseFlag(value), "1");
734  value = 0;
735  EXPECT_EQ(absl::UnparseFlag(value), "0");
736  value = -1;
737  EXPECT_EQ(absl::UnparseFlag(value), "-1");
738  value = 123456789L;
739  EXPECT_EQ(absl::UnparseFlag(value), "123456789");
740  value = -987654321L;
741  EXPECT_EQ(absl::UnparseFlag(value), "-987654321");
742  value = 0x7FFFFFFFFFFFFFFF;
743  EXPECT_EQ(absl::UnparseFlag(value), "9223372036854775807");
744  value = 0xFFFFFFFFFFFFFFFF;
745  EXPECT_EQ(absl::UnparseFlag(value), "-1");
746 }
747 
748 // --------------------------------------------------------------------
749 
750 TEST(MarshallingTest, TestUint64Unparsing) {
751  uint64_t value;
752 
753  value = 1;
754  EXPECT_EQ(absl::UnparseFlag(value), "1");
755  value = 0;
756  EXPECT_EQ(absl::UnparseFlag(value), "0");
757  value = 123456789L;
758  EXPECT_EQ(absl::UnparseFlag(value), "123456789");
759  value = 0xFFFFFFFFFFFFFFFF;
760  EXPECT_EQ(absl::UnparseFlag(value), "18446744073709551615");
761 }
762 
763 // --------------------------------------------------------------------
764 
765 TEST(MarshallingTest, TestFloatUnparsing) {
766  float value;
767 
768  value = 1.1f;
769  EXPECT_EQ(absl::UnparseFlag(value), "1.1");
770  value = 0.01f;
771  EXPECT_EQ(absl::UnparseFlag(value), "0.01");
772  value = 1.23e-2f;
773  EXPECT_EQ(absl::UnparseFlag(value), "0.0123");
774  value = -0.71f;
775  EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
776 }
777 
778 // --------------------------------------------------------------------
779 
780 TEST(MarshallingTest, TestDoubleUnparsing) {
781  double value;
782 
783  value = 1.1;
784  EXPECT_EQ(absl::UnparseFlag(value), "1.1");
785  value = 0.01;
786  EXPECT_EQ(absl::UnparseFlag(value), "0.01");
787  value = 1.23e-2;
788  EXPECT_EQ(absl::UnparseFlag(value), "0.0123");
789  value = -0.71;
790  EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
791  value = -0;
792  EXPECT_EQ(absl::UnparseFlag(value), "0");
793  value = std::nan("");
794  EXPECT_EQ(absl::UnparseFlag(value), "nan");
795  value = std::numeric_limits<double>::infinity();
796  EXPECT_EQ(absl::UnparseFlag(value), "inf");
797 }
798 
799 // --------------------------------------------------------------------
800 
801 TEST(MarshallingTest, TestStringUnparsing) {
802  EXPECT_EQ(absl::UnparseFlag(""), "");
803  EXPECT_EQ(absl::UnparseFlag(" "), " ");
804  EXPECT_EQ(absl::UnparseFlag("qwerty"), "qwerty");
805  EXPECT_EQ(absl::UnparseFlag("ASDFGH"), "ASDFGH");
806  EXPECT_EQ(absl::UnparseFlag("\n\t "), "\n\t ");
807 }
808 
809 // --------------------------------------------------------------------
810 
811 template <typename T>
812 void TestRoundtrip(T v) {
813  T new_v;
814  std::string err;
815  EXPECT_TRUE(absl::ParseFlag(absl::UnparseFlag(v), &new_v, &err));
816  EXPECT_EQ(new_v, v);
817 }
818 
819 TEST(MarshallingTest, TestFloatRoundTrip) {
820  TestRoundtrip(0.1f);
821  TestRoundtrip(0.12f);
822  TestRoundtrip(0.123f);
823  TestRoundtrip(0.1234f);
824  TestRoundtrip(0.12345f);
825  TestRoundtrip(0.123456f);
826  TestRoundtrip(0.1234567f);
827  TestRoundtrip(0.12345678f);
828 
829  TestRoundtrip(0.1e20f);
830  TestRoundtrip(0.12e20f);
831  TestRoundtrip(0.123e20f);
832  TestRoundtrip(0.1234e20f);
833  TestRoundtrip(0.12345e20f);
834  TestRoundtrip(0.123456e20f);
835  TestRoundtrip(0.1234567e20f);
836  TestRoundtrip(0.12345678e20f);
837 
838  TestRoundtrip(0.1e-20f);
839  TestRoundtrip(0.12e-20f);
840  TestRoundtrip(0.123e-20f);
841  TestRoundtrip(0.1234e-20f);
842  TestRoundtrip(0.12345e-20f);
843  TestRoundtrip(0.123456e-20f);
844  TestRoundtrip(0.1234567e-20f);
845  TestRoundtrip(0.12345678e-20f);
846 }
847 
848 TEST(MarshallingTest, TestDoubleRoundTrip) {
849  TestRoundtrip(0.1);
850  TestRoundtrip(0.12);
851  TestRoundtrip(0.123);
852  TestRoundtrip(0.1234);
853  TestRoundtrip(0.12345);
854  TestRoundtrip(0.123456);
855  TestRoundtrip(0.1234567);
856  TestRoundtrip(0.12345678);
857  TestRoundtrip(0.123456789);
858  TestRoundtrip(0.1234567891);
859  TestRoundtrip(0.12345678912);
860  TestRoundtrip(0.123456789123);
861  TestRoundtrip(0.1234567891234);
862  TestRoundtrip(0.12345678912345);
863  TestRoundtrip(0.123456789123456);
864  TestRoundtrip(0.1234567891234567);
865  TestRoundtrip(0.12345678912345678);
866 
867  TestRoundtrip(0.1e50);
868  TestRoundtrip(0.12e50);
869  TestRoundtrip(0.123e50);
870  TestRoundtrip(0.1234e50);
871  TestRoundtrip(0.12345e50);
872  TestRoundtrip(0.123456e50);
873  TestRoundtrip(0.1234567e50);
874  TestRoundtrip(0.12345678e50);
875  TestRoundtrip(0.123456789e50);
876  TestRoundtrip(0.1234567891e50);
877  TestRoundtrip(0.12345678912e50);
878  TestRoundtrip(0.123456789123e50);
879  TestRoundtrip(0.1234567891234e50);
880  TestRoundtrip(0.12345678912345e50);
881  TestRoundtrip(0.123456789123456e50);
882  TestRoundtrip(0.1234567891234567e50);
883  TestRoundtrip(0.12345678912345678e50);
884 
885  TestRoundtrip(0.1e-50);
886  TestRoundtrip(0.12e-50);
887  TestRoundtrip(0.123e-50);
888  TestRoundtrip(0.1234e-50);
889  TestRoundtrip(0.12345e-50);
890  TestRoundtrip(0.123456e-50);
891  TestRoundtrip(0.1234567e-50);
892  TestRoundtrip(0.12345678e-50);
893  TestRoundtrip(0.123456789e-50);
894  TestRoundtrip(0.1234567891e-50);
895  TestRoundtrip(0.12345678912e-50);
896  TestRoundtrip(0.123456789123e-50);
897  TestRoundtrip(0.1234567891234e-50);
898  TestRoundtrip(0.12345678912345e-50);
899  TestRoundtrip(0.123456789123456e-50);
900  TestRoundtrip(0.1234567891234567e-50);
901  TestRoundtrip(0.12345678912345678e-50);
902 }
903 
904 } // namespace
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1970
absl::ParseFlag
ABSL_NAMESPACE_BEGIN bool ParseFlag(absl::string_view input, T *dst, std::string *error)
Definition: abseil-cpp/absl/flags/marshalling.h:328
tests.google.protobuf.internal.message_test.isnan
def isnan(val)
Definition: bloaty/third_party/protobuf/python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/message_test.py:65
uint16_t
unsigned short uint16_t
Definition: stdint-msvc2008.h:79
testing::internal::string
::std::string string
Definition: bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h:881
error_ref_leak.err
err
Definition: error_ref_leak.py:35
absl::UnparseFlag
std::string UnparseFlag(const T &v)
Definition: abseil-cpp/absl/flags/marshalling.h:342
T
#define T(upbtypeconst, upbtype, ctype, default_value)
EXPECT_EQ
#define EXPECT_EQ(a, b)
Definition: iomgr/time_averaged_stats_test.cc:27
uint32_t
unsigned int uint32_t
Definition: stdint-msvc2008.h:80
autogen_x86imm.f
f
Definition: autogen_x86imm.py:9
int16_t
signed short int16_t
Definition: stdint-msvc2008.h:76
int64_t
signed __int64 int64_t
Definition: stdint-msvc2008.h:89
TEST
#define TEST(name, init_size,...)
Definition: arena_test.cc:75
EXPECT_NE
#define EXPECT_NE(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2028
setup.v
v
Definition: third_party/bloaty/third_party/capstone/bindings/python/setup.py:42
uint64_t
unsigned __int64 uint64_t
Definition: stdint-msvc2008.h:90
stdint.h
value
const char * value
Definition: hpack_parser_table.cc:165
L
lua_State * L
Definition: upb/upb/bindings/lua/main.c:35
tests.google.protobuf.internal.message_test.isinf
def isinf(val)
Definition: bloaty/third_party/protobuf/python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/message_test.py:68
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1967
EXPECT_DOUBLE_EQ
#define EXPECT_DOUBLE_EQ(a, b)
Definition: iomgr/time_averaged_stats_test.cc:28
EXPECT_NEAR
#define EXPECT_NEAR(val1, val2, abs_error)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2143
EXPECT_FLOAT_EQ
#define EXPECT_FLOAT_EQ(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2127
int32_t
signed int int32_t
Definition: stdint-msvc2008.h:77

grpc
Author(s):
autogenerated on Fri May 16 2025 02:59:22