xref: /aosp_15_r20/external/abseil-cpp/absl/flags/marshalling_test.cc (revision 9356374a3709195abf420251b3e825997ff56c0f) 
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 
TEST(MarshallingTest,TestBoolParsing)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 
TEST(MarshallingTest,TestInt16Parsing)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   EXPECT_TRUE(absl::ParseFlag("-0x7FFD", &value, &err));
141   EXPECT_EQ(value, -32765);
142   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
143   EXPECT_EQ(value, 49);
144 
145   // Whitespace handling
146   EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
147   EXPECT_EQ(value, 10);
148   EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
149   EXPECT_EQ(value, 11);
150   EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
151   EXPECT_EQ(value, 12);
152   EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
153   EXPECT_EQ(value, 34);
154 
155   // Invalid values.
156   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
157   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
158   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
159   EXPECT_FALSE(absl::ParseFlag("40000", &value, &err));
160   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
161   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
162   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
163   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
164   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
165 }
166 
167 // --------------------------------------------------------------------
168 
TEST(MarshallingTest,TestUint16Parsing)169 TEST(MarshallingTest, TestUint16Parsing) {
170   std::string err;
171   uint16_t value;
172 
173   // Decimal values.
174   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
175   EXPECT_EQ(value, 1);
176   EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
177   EXPECT_EQ(value, 0);
178   EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
179   EXPECT_EQ(value, 123);
180   EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
181   EXPECT_EQ(value, 3);
182 
183   // Leading zero values.
184   EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
185   EXPECT_EQ(value, 1);
186   EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
187   EXPECT_EQ(value, 1);
188   EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
189   EXPECT_EQ(value, 100);
190 
191   // Hex values.
192   EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
193   EXPECT_EQ(value, 16);
194   EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
195   EXPECT_EQ(value, 564);
196   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
197   EXPECT_EQ(value, 49);
198 
199   // Whitespace handling
200   EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
201   EXPECT_EQ(value, 10);
202   EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
203   EXPECT_EQ(value, 11);
204   EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
205   EXPECT_EQ(value, 12);
206   EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
207   EXPECT_EQ(value, 34);
208 
209   // Invalid values.
210   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
211   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
212   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
213   EXPECT_FALSE(absl::ParseFlag("70000", &value, &err));
214   EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
215   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
216   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
217   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
218   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
219   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
220 }
221 
222 // --------------------------------------------------------------------
223 
TEST(MarshallingTest,TestInt32Parsing)224 TEST(MarshallingTest, TestInt32Parsing) {
225   std::string err;
226   int32_t value;
227 
228   // Decimal values.
229   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
230   EXPECT_EQ(value, 1);
231   EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
232   EXPECT_EQ(value, 0);
233   EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
234   EXPECT_EQ(value, -1);
235   EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
236   EXPECT_EQ(value, 123);
237   EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
238   EXPECT_EQ(value, -98765);
239   EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
240   EXPECT_EQ(value, 3);
241 
242   // Leading zero values.
243   EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
244   EXPECT_EQ(value, 1);
245   EXPECT_TRUE(absl::ParseFlag("-001", &value, &err));
246   EXPECT_EQ(value, -1);
247   EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
248   EXPECT_EQ(value, 100);
249 
250   // Hex values.
251   EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
252   EXPECT_EQ(value, 16);
253   EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
254   EXPECT_EQ(value, 564);
255 
256   EXPECT_TRUE(absl::ParseFlag("-0x7FFFFFFD", &value, &err));
257   EXPECT_EQ(value, -2147483645);
258   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
259   EXPECT_EQ(value, 49);
260 
261   // Whitespace handling
262   EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
263   EXPECT_EQ(value, 10);
264   EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
265   EXPECT_EQ(value, 11);
266   EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
267   EXPECT_EQ(value, 12);
268   EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
269   EXPECT_EQ(value, 34);
270 
271   // Invalid values.
272   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
273   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
274   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
275   EXPECT_FALSE(absl::ParseFlag("70000000000", &value, &err));
276   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
277   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
278   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
279   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
280   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
281 }
282 
283 // --------------------------------------------------------------------
284 
TEST(MarshallingTest,TestUint32Parsing)285 TEST(MarshallingTest, TestUint32Parsing) {
286   std::string err;
287   uint32_t value;
288 
289   // Decimal values.
290   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
291   EXPECT_EQ(value, 1);
292   EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
293   EXPECT_EQ(value, 0);
294   EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
295   EXPECT_EQ(value, 123);
296   EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
297   EXPECT_EQ(value, 3);
298 
299   // Leading zero values.
300   EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
301   EXPECT_EQ(value, 1);
302   EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
303   EXPECT_EQ(value, 100);
304 
305   // Hex values.
306   EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
307   EXPECT_EQ(value, 16);
308   EXPECT_TRUE(absl::ParseFlag("0X234", &value, &err));
309   EXPECT_EQ(value, 564);
310   EXPECT_TRUE(absl::ParseFlag("0xFFFFFFFD", &value, &err));
311   EXPECT_EQ(value, 4294967293);
312   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
313   EXPECT_EQ(value, 49);
314 
315   // Whitespace handling
316   EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
317   EXPECT_EQ(value, 10);
318   EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
319   EXPECT_EQ(value, 11);
320   EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
321   EXPECT_EQ(value, 12);
322   EXPECT_TRUE(absl::ParseFlag(" 0x22    ", &value, &err));
323   EXPECT_EQ(value, 34);
324 
325   // Invalid values.
326   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
327   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
328   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
329   EXPECT_FALSE(absl::ParseFlag("140000000000", &value, &err));
330   EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
331   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
332   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
333   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
334   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
335   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
336 }
337 
338 // --------------------------------------------------------------------
339 
TEST(MarshallingTest,TestInt64Parsing)340 TEST(MarshallingTest, TestInt64Parsing) {
341   std::string err;
342   int64_t value;
343 
344   // Decimal values.
345   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
346   EXPECT_EQ(value, 1);
347   EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
348   EXPECT_EQ(value, 0);
349   EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
350   EXPECT_EQ(value, -1);
351   EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
352   EXPECT_EQ(value, 123);
353   EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
354   EXPECT_EQ(value, -98765);
355   EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
356   EXPECT_EQ(value, 3);
357 
358   // Leading zero values.
359   EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
360   EXPECT_EQ(value, 1);
361   EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
362   EXPECT_EQ(value, 1);
363   EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
364   EXPECT_EQ(value, 100);
365 
366   // Hex values.
367   EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
368   EXPECT_EQ(value, 16);
369   EXPECT_TRUE(absl::ParseFlag("0XFFFAAABBBCCCDDD", &value, &err));
370   EXPECT_EQ(value, 1152827684197027293);
371   EXPECT_TRUE(absl::ParseFlag("-0x7FFFFFFFFFFFFFFE", &value, &err));
372   EXPECT_EQ(value, -9223372036854775806);
373   EXPECT_TRUE(absl::ParseFlag("-0x02", &value, &err));
374   EXPECT_EQ(value, -2);
375   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
376   EXPECT_EQ(value, 49);
377 
378   // Whitespace handling
379   EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
380   EXPECT_EQ(value, 10);
381   EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
382   EXPECT_EQ(value, 11);
383   EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
384   EXPECT_EQ(value, 12);
385   EXPECT_TRUE(absl::ParseFlag(" 0x7F    ", &value, &err));
386   EXPECT_EQ(value, 127);
387 
388   // Invalid values.
389   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
390   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
391   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
392   EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err));
393   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
394   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
395   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
396   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
397   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
398 }
399 
400 // --------------------------------------------------------------------
401 
TEST(MarshallingTest,TestUInt64Parsing)402 TEST(MarshallingTest, TestUInt64Parsing) {
403   std::string err;
404   uint64_t value;
405 
406   // Decimal values.
407   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
408   EXPECT_EQ(value, 1);
409   EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
410   EXPECT_EQ(value, 0);
411   EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
412   EXPECT_EQ(value, 123);
413   EXPECT_TRUE(absl::ParseFlag("+13", &value, &err));
414   EXPECT_EQ(value, 13);
415 
416   // Leading zero values.
417   EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
418   EXPECT_EQ(value, 1);
419   EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
420   EXPECT_EQ(value, 1);
421   EXPECT_TRUE(absl::ParseFlag("0000300", &value, &err));
422   EXPECT_EQ(value, 300);
423 
424   // Hex values.
425   EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
426   EXPECT_EQ(value, 16);
427   EXPECT_TRUE(absl::ParseFlag("0XFFFF", &value, &err));
428   EXPECT_EQ(value, 65535);
429   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
430   EXPECT_EQ(value, 49);
431 
432   // Whitespace handling
433   EXPECT_TRUE(absl::ParseFlag("10  ", &value, &err));
434   EXPECT_EQ(value, 10);
435   EXPECT_TRUE(absl::ParseFlag("  11", &value, &err));
436   EXPECT_EQ(value, 11);
437   EXPECT_TRUE(absl::ParseFlag("  012  ", &value, &err));
438   EXPECT_EQ(value, 12);
439 
440   // Invalid values.
441   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
442   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
443   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
444   EXPECT_FALSE(absl::ParseFlag("0xFFFFFFFFFFFFFFFFFF", &value, &err));
445   EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
446   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
447   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
448   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
449   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
450   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
451 }
452 
453 // --------------------------------------------------------------------
454 
TEST(MarshallingTest,TestInt128Parsing)455 TEST(MarshallingTest, TestInt128Parsing) {
456   std::string err;
457   absl::int128 value;
458 
459   // Decimal values.
460   EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
461   EXPECT_EQ(value, 0);
462   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
463   EXPECT_EQ(value, 1);
464   EXPECT_TRUE(absl::ParseFlag("-1", &value, &err));
465   EXPECT_EQ(value, -1);
466   EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
467   EXPECT_EQ(value, 123);
468   EXPECT_TRUE(absl::ParseFlag("-98765", &value, &err));
469   EXPECT_EQ(value, -98765);
470   EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
471   EXPECT_EQ(value, 3);
472 
473   // Leading zero values.
474   EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
475   EXPECT_EQ(value, 1);
476   EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
477   EXPECT_EQ(value, 1);
478   EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
479   EXPECT_EQ(value, 100);
480 
481   // Hex values.
482   EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
483   EXPECT_EQ(value, 16);
484   EXPECT_TRUE(absl::ParseFlag("0xFFFAAABBBCCCDDD", &value, &err));
485   EXPECT_EQ(value, 1152827684197027293);
486   EXPECT_TRUE(absl::ParseFlag("0xFFF0FFFFFFFFFFFFFFF", &value, &err));
487   EXPECT_EQ(value, absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF));
488 
489   EXPECT_TRUE(absl::ParseFlag("-0x10000000000000000", &value, &err));
490   EXPECT_EQ(value, absl::MakeInt128(-1, 0));
491   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
492   EXPECT_EQ(value, 49);
493 
494   // Whitespace handling
495   EXPECT_TRUE(absl::ParseFlag("16  ", &value, &err));
496   EXPECT_EQ(value, 16);
497   EXPECT_TRUE(absl::ParseFlag("  16", &value, &err));
498   EXPECT_EQ(value, 16);
499   EXPECT_TRUE(absl::ParseFlag("  0100  ", &value, &err));
500   EXPECT_EQ(value, 100);
501   EXPECT_TRUE(absl::ParseFlag(" 0x7B    ", &value, &err));
502   EXPECT_EQ(value, 123);
503 
504   // Invalid values.
505   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
506   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
507   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
508   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
509   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
510   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
511   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
512   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
513 }
514 
515 // --------------------------------------------------------------------
516 
TEST(MarshallingTest,TestUint128Parsing)517 TEST(MarshallingTest, TestUint128Parsing) {
518   std::string err;
519   absl::uint128 value;
520 
521   // Decimal values.
522   EXPECT_TRUE(absl::ParseFlag("0", &value, &err));
523   EXPECT_EQ(value, 0);
524   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
525   EXPECT_EQ(value, 1);
526   EXPECT_TRUE(absl::ParseFlag("123", &value, &err));
527   EXPECT_EQ(value, 123);
528   EXPECT_TRUE(absl::ParseFlag("+3", &value, &err));
529   EXPECT_EQ(value, 3);
530 
531   // Leading zero values.
532   EXPECT_TRUE(absl::ParseFlag("01", &value, &err));
533   EXPECT_EQ(value, 1);
534   EXPECT_TRUE(absl::ParseFlag("001", &value, &err));
535   EXPECT_EQ(value, 1);
536   EXPECT_TRUE(absl::ParseFlag("0000100", &value, &err));
537   EXPECT_EQ(value, 100);
538 
539   // Hex values.
540   EXPECT_TRUE(absl::ParseFlag("0x10", &value, &err));
541   EXPECT_EQ(value, 16);
542   EXPECT_TRUE(absl::ParseFlag("0xFFFAAABBBCCCDDD", &value, &err));
543   EXPECT_EQ(value, 1152827684197027293);
544   EXPECT_TRUE(absl::ParseFlag("0xFFF0FFFFFFFFFFFFFFF", &value, &err));
545   EXPECT_EQ(value, absl::MakeInt128(0x000000000000fff, 0xFFFFFFFFFFFFFFF));
546   EXPECT_TRUE(absl::ParseFlag("+0x31", &value, &err));
547   EXPECT_EQ(value, 49);
548 
549   // Whitespace handling
550   EXPECT_TRUE(absl::ParseFlag("16  ", &value, &err));
551   EXPECT_EQ(value, 16);
552   EXPECT_TRUE(absl::ParseFlag("  16", &value, &err));
553   EXPECT_EQ(value, 16);
554   EXPECT_TRUE(absl::ParseFlag("  0100  ", &value, &err));
555   EXPECT_EQ(value, 100);
556   EXPECT_TRUE(absl::ParseFlag(" 0x7B    ", &value, &err));
557   EXPECT_EQ(value, 123);
558 
559   // Invalid values.
560   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
561   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
562   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
563   EXPECT_FALSE(absl::ParseFlag("-1", &value, &err));
564   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
565   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
566   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
567   EXPECT_FALSE(absl::ParseFlag("2U", &value, &err));
568   EXPECT_FALSE(absl::ParseFlag("FFF", &value, &err));
569   EXPECT_FALSE(absl::ParseFlag("-0x10000000000000000", &value, &err));
570 }
571 
572 // --------------------------------------------------------------------
573 
TEST(MarshallingTest,TestFloatParsing)574 TEST(MarshallingTest, TestFloatParsing) {
575   std::string err;
576   float value;
577 
578   // Ordinary values.
579   EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err));
580   EXPECT_FLOAT_EQ(value, 1.3f);
581   EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err));
582   EXPECT_DOUBLE_EQ(value, -0.1f);
583   EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err));
584   EXPECT_DOUBLE_EQ(value, 0.01f);
585 
586   // Scientific values.
587   EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err));
588   EXPECT_DOUBLE_EQ(value, 1.2e3f);
589   EXPECT_TRUE(absl::ParseFlag("9.8765402e-37", &value, &err));
590   EXPECT_DOUBLE_EQ(value, 9.8765402e-37f);
591   EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err));
592   EXPECT_DOUBLE_EQ(value, 0.11e+3f);
593   EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err));
594   EXPECT_DOUBLE_EQ(value, 0.f);
595   EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err));
596   EXPECT_TRUE(std::isinf(value));
597 
598   // Leading zero values.
599   EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err));
600   EXPECT_DOUBLE_EQ(value, 1.6f);
601   EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err));
602   EXPECT_DOUBLE_EQ(value, 0.0001f);
603 
604   // Trailing zero values.
605   EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err));
606   EXPECT_DOUBLE_EQ(value, -5.1f);
607 
608   // Exceptional values.
609   EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err));
610   EXPECT_TRUE(std::isnan(value));
611   EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err));
612   EXPECT_TRUE(std::isinf(value));
613 
614   // Hex values
615   EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err));
616   EXPECT_DOUBLE_EQ(value, 66096.f);
617   EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err));
618   EXPECT_NEAR(value, -60.4092f, 5e-5f);
619   EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err));
620   EXPECT_NEAR(value, 1.01328e-05f, 5e-11f);
621   EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err));
622   EXPECT_NEAR(value, 0.0078125f, 5e-8f);
623 
624   // Whitespace handling
625   EXPECT_TRUE(absl::ParseFlag("10.1  ", &value, &err));
626   EXPECT_DOUBLE_EQ(value, 10.1f);
627   EXPECT_TRUE(absl::ParseFlag("  2.34", &value, &err));
628   EXPECT_DOUBLE_EQ(value, 2.34f);
629   EXPECT_TRUE(absl::ParseFlag("  5.7  ", &value, &err));
630   EXPECT_DOUBLE_EQ(value, 5.7f);
631   EXPECT_TRUE(absl::ParseFlag("  -0xE0.F3p01  ", &value, &err));
632   EXPECT_NEAR(value, -449.8984375f, 5e-8f);
633 
634   // Invalid values.
635   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
636   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
637   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
638   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
639   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
640   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
641   EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err));
642   EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err));
643   // TODO(rogeeff): below assertion should fail
644   EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err));
645 }
646 
647 // --------------------------------------------------------------------
648 
TEST(MarshallingTest,TestDoubleParsing)649 TEST(MarshallingTest, TestDoubleParsing) {
650   std::string err;
651   double value;
652 
653   // Ordinary values.
654   EXPECT_TRUE(absl::ParseFlag("1.3", &value, &err));
655   EXPECT_DOUBLE_EQ(value, 1.3);
656   EXPECT_TRUE(absl::ParseFlag("-0.1", &value, &err));
657   EXPECT_DOUBLE_EQ(value, -0.1);
658   EXPECT_TRUE(absl::ParseFlag("+0.01", &value, &err));
659   EXPECT_DOUBLE_EQ(value, 0.01);
660 
661   // Scientific values.
662   EXPECT_TRUE(absl::ParseFlag("1.2e3", &value, &err));
663   EXPECT_DOUBLE_EQ(value, 1.2e3);
664   EXPECT_TRUE(absl::ParseFlag("9.00000002e-123", &value, &err));
665   EXPECT_DOUBLE_EQ(value, 9.00000002e-123);
666   EXPECT_TRUE(absl::ParseFlag("0.11e+3", &value, &err));
667   EXPECT_DOUBLE_EQ(value, 0.11e+3);
668   EXPECT_TRUE(absl::ParseFlag("1.e-2300", &value, &err));
669   EXPECT_DOUBLE_EQ(value, 0);
670   EXPECT_TRUE(absl::ParseFlag("1.e+2300", &value, &err));
671   EXPECT_TRUE(std::isinf(value));
672 
673   // Leading zero values.
674   EXPECT_TRUE(absl::ParseFlag("01.6", &value, &err));
675   EXPECT_DOUBLE_EQ(value, 1.6);
676   EXPECT_TRUE(absl::ParseFlag("000.0001", &value, &err));
677   EXPECT_DOUBLE_EQ(value, 0.0001);
678 
679   // Trailing zero values.
680   EXPECT_TRUE(absl::ParseFlag("-5.1000", &value, &err));
681   EXPECT_DOUBLE_EQ(value, -5.1);
682 
683   // Exceptional values.
684   EXPECT_TRUE(absl::ParseFlag("NaN", &value, &err));
685   EXPECT_TRUE(std::isnan(value));
686   EXPECT_TRUE(absl::ParseFlag("nan", &value, &err));
687   EXPECT_TRUE(std::isnan(value));
688   EXPECT_TRUE(absl::ParseFlag("Inf", &value, &err));
689   EXPECT_TRUE(std::isinf(value));
690   EXPECT_TRUE(absl::ParseFlag("inf", &value, &err));
691   EXPECT_TRUE(std::isinf(value));
692 
693   // Hex values
694   EXPECT_TRUE(absl::ParseFlag("0x10.23p12", &value, &err));
695   EXPECT_DOUBLE_EQ(value, 66096);
696   EXPECT_TRUE(absl::ParseFlag("-0xF1.A3p-2", &value, &err));
697   EXPECT_NEAR(value, -60.4092, 5e-5);
698   EXPECT_TRUE(absl::ParseFlag("+0x0.0AAp-12", &value, &err));
699   EXPECT_NEAR(value, 1.01328e-05, 5e-11);
700   EXPECT_TRUE(absl::ParseFlag("0x.01p1", &value, &err));
701   EXPECT_NEAR(value, 0.0078125, 5e-8);
702 
703   // Whitespace handling
704   EXPECT_TRUE(absl::ParseFlag("10.1  ", &value, &err));
705   EXPECT_DOUBLE_EQ(value, 10.1);
706   EXPECT_TRUE(absl::ParseFlag("  2.34", &value, &err));
707   EXPECT_DOUBLE_EQ(value, 2.34);
708   EXPECT_TRUE(absl::ParseFlag("  5.7  ", &value, &err));
709   EXPECT_DOUBLE_EQ(value, 5.7);
710   EXPECT_TRUE(absl::ParseFlag("  -0xE0.F3p01  ", &value, &err));
711   EXPECT_NEAR(value, -449.8984375, 5e-8);
712 
713   // Invalid values.
714   EXPECT_FALSE(absl::ParseFlag("", &value, &err));
715   EXPECT_FALSE(absl::ParseFlag(" ", &value, &err));
716   EXPECT_FALSE(absl::ParseFlag("  ", &value, &err));
717   EXPECT_FALSE(absl::ParseFlag("--1", &value, &err));
718   EXPECT_FALSE(absl::ParseFlag("\n", &value, &err));
719   EXPECT_FALSE(absl::ParseFlag("\t", &value, &err));
720   EXPECT_FALSE(absl::ParseFlag("2.3xxx", &value, &err));
721   EXPECT_FALSE(absl::ParseFlag("0x0.1pAA", &value, &err));
722   // TODO(rogeeff): below assertion should fail
723   EXPECT_TRUE(absl::ParseFlag("0x0.1", &value, &err));
724 }
725 
726 // --------------------------------------------------------------------
727 
TEST(MarshallingTest,TestStringParsing)728 TEST(MarshallingTest, TestStringParsing) {
729   std::string err;
730   std::string value;
731 
732   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
733   EXPECT_EQ(value, "");
734   EXPECT_TRUE(absl::ParseFlag(" ", &value, &err));
735   EXPECT_EQ(value, " ");
736   EXPECT_TRUE(absl::ParseFlag("   ", &value, &err));
737   EXPECT_EQ(value, "   ");
738   EXPECT_TRUE(absl::ParseFlag("\n", &value, &err));
739   EXPECT_EQ(value, "\n");
740   EXPECT_TRUE(absl::ParseFlag("\t", &value, &err));
741   EXPECT_EQ(value, "\t");
742   EXPECT_TRUE(absl::ParseFlag("asdfg", &value, &err));
743   EXPECT_EQ(value, "asdfg");
744   EXPECT_TRUE(absl::ParseFlag("asdf ghjk", &value, &err));
745   EXPECT_EQ(value, "asdf ghjk");
746   EXPECT_TRUE(absl::ParseFlag("a\nb\nc", &value, &err));
747   EXPECT_EQ(value, "a\nb\nc");
748   EXPECT_TRUE(absl::ParseFlag("asd\0fgh", &value, &err));
749   EXPECT_EQ(value, "asd");
750   EXPECT_TRUE(absl::ParseFlag("\\\\", &value, &err));
751   EXPECT_EQ(value, "\\\\");
752 }
753 
754 // --------------------------------------------------------------------
755 
TEST(MarshallingTest,TestVectorOfStringParsing)756 TEST(MarshallingTest, TestVectorOfStringParsing) {
757   std::string err;
758   std::vector<std::string> value;
759 
760   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
761   EXPECT_EQ(value, std::vector<std::string>{});
762   EXPECT_TRUE(absl::ParseFlag("1", &value, &err));
763   EXPECT_EQ(value, std::vector<std::string>({"1"}));
764   EXPECT_TRUE(absl::ParseFlag("a,b", &value, &err));
765   EXPECT_EQ(value, std::vector<std::string>({"a", "b"}));
766   EXPECT_TRUE(absl::ParseFlag("a,b,c,", &value, &err));
767   EXPECT_EQ(value, std::vector<std::string>({"a", "b", "c", ""}));
768   EXPECT_TRUE(absl::ParseFlag("a,,", &value, &err));
769   EXPECT_EQ(value, std::vector<std::string>({"a", "", ""}));
770   EXPECT_TRUE(absl::ParseFlag(",", &value, &err));
771   EXPECT_EQ(value, std::vector<std::string>({"", ""}));
772   EXPECT_TRUE(absl::ParseFlag("a, b,c ", &value, &err));
773   EXPECT_EQ(value, std::vector<std::string>({"a", " b", "c "}));
774 }
775 
776 // --------------------------------------------------------------------
777 
TEST(MarshallingTest,TestOptionalBoolParsing)778 TEST(MarshallingTest, TestOptionalBoolParsing) {
779   std::string err;
780   absl::optional<bool> value;
781 
782   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
783   EXPECT_FALSE(value.has_value());
784 
785   EXPECT_TRUE(absl::ParseFlag("true", &value, &err));
786   EXPECT_TRUE(value.has_value());
787   EXPECT_TRUE(*value);
788 
789   EXPECT_TRUE(absl::ParseFlag("false", &value, &err));
790   EXPECT_TRUE(value.has_value());
791   EXPECT_FALSE(*value);
792 
793   EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err));
794 }
795 
796 // --------------------------------------------------------------------
797 
TEST(MarshallingTest,TestOptionalIntParsing)798 TEST(MarshallingTest, TestOptionalIntParsing) {
799   std::string err;
800   absl::optional<int> value;
801 
802   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
803   EXPECT_FALSE(value.has_value());
804 
805   EXPECT_TRUE(absl::ParseFlag("10", &value, &err));
806   EXPECT_TRUE(value.has_value());
807   EXPECT_EQ(*value, 10);
808 
809   EXPECT_TRUE(absl::ParseFlag("0x1F", &value, &err));
810   EXPECT_TRUE(value.has_value());
811   EXPECT_EQ(*value, 31);
812 
813   EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err));
814 }
815 
816 // --------------------------------------------------------------------
817 
TEST(MarshallingTest,TestOptionalDoubleParsing)818 TEST(MarshallingTest, TestOptionalDoubleParsing) {
819   std::string err;
820   absl::optional<double> value;
821 
822   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
823   EXPECT_FALSE(value.has_value());
824 
825   EXPECT_TRUE(absl::ParseFlag("1.11", &value, &err));
826   EXPECT_TRUE(value.has_value());
827   EXPECT_EQ(*value, 1.11);
828 
829   EXPECT_TRUE(absl::ParseFlag("-0.12", &value, &err));
830   EXPECT_TRUE(value.has_value());
831   EXPECT_EQ(*value, -0.12);
832 
833   EXPECT_FALSE(absl::ParseFlag("nullopt", &value, &err));
834 }
835 
836 // --------------------------------------------------------------------
837 
TEST(MarshallingTest,TestOptionalStringParsing)838 TEST(MarshallingTest, TestOptionalStringParsing) {
839   std::string err;
840   absl::optional<std::string> value;
841 
842   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
843   EXPECT_FALSE(value.has_value());
844 
845   EXPECT_TRUE(absl::ParseFlag(" ", &value, &err));
846   EXPECT_TRUE(value.has_value());
847   EXPECT_EQ(*value, " ");
848 
849   EXPECT_TRUE(absl::ParseFlag("aqswde", &value, &err));
850   EXPECT_TRUE(value.has_value());
851   EXPECT_EQ(*value, "aqswde");
852 
853   EXPECT_TRUE(absl::ParseFlag("nullopt", &value, &err));
854   EXPECT_TRUE(value.has_value());
855   EXPECT_EQ(*value, "nullopt");
856 }
857 
858 // --------------------------------------------------------------------
859 
TEST(MarshallingTest,TestBoolUnparsing)860 TEST(MarshallingTest, TestBoolUnparsing) {
861   EXPECT_EQ(absl::UnparseFlag(true), "true");
862   EXPECT_EQ(absl::UnparseFlag(false), "false");
863 }
864 
865 // --------------------------------------------------------------------
866 
TEST(MarshallingTest,TestInt16Unparsing)867 TEST(MarshallingTest, TestInt16Unparsing) {
868   int16_t value;
869 
870   value = 1;
871   EXPECT_EQ(absl::UnparseFlag(value), "1");
872   value = 0;
873   EXPECT_EQ(absl::UnparseFlag(value), "0");
874   value = -1;
875   EXPECT_EQ(absl::UnparseFlag(value), "-1");
876   value = 9876;
877   EXPECT_EQ(absl::UnparseFlag(value), "9876");
878   value = -987;
879   EXPECT_EQ(absl::UnparseFlag(value), "-987");
880 }
881 
882 // --------------------------------------------------------------------
883 
TEST(MarshallingTest,TestUint16Unparsing)884 TEST(MarshallingTest, TestUint16Unparsing) {
885   uint16_t value;
886 
887   value = 1;
888   EXPECT_EQ(absl::UnparseFlag(value), "1");
889   value = 0;
890   EXPECT_EQ(absl::UnparseFlag(value), "0");
891   value = 19876;
892   EXPECT_EQ(absl::UnparseFlag(value), "19876");
893 }
894 
895 // --------------------------------------------------------------------
896 
TEST(MarshallingTest,TestInt32Unparsing)897 TEST(MarshallingTest, TestInt32Unparsing) {
898   int32_t value;
899 
900   value = 1;
901   EXPECT_EQ(absl::UnparseFlag(value), "1");
902   value = 0;
903   EXPECT_EQ(absl::UnparseFlag(value), "0");
904   value = -1;
905   EXPECT_EQ(absl::UnparseFlag(value), "-1");
906   value = 12345;
907   EXPECT_EQ(absl::UnparseFlag(value), "12345");
908   value = -987;
909   EXPECT_EQ(absl::UnparseFlag(value), "-987");
910 }
911 
912 // --------------------------------------------------------------------
913 
TEST(MarshallingTest,TestUint32Unparsing)914 TEST(MarshallingTest, TestUint32Unparsing) {
915   uint32_t value;
916 
917   value = 1;
918   EXPECT_EQ(absl::UnparseFlag(value), "1");
919   value = 0;
920   EXPECT_EQ(absl::UnparseFlag(value), "0");
921   value = 1234500;
922   EXPECT_EQ(absl::UnparseFlag(value), "1234500");
923 }
924 
925 // --------------------------------------------------------------------
926 
TEST(MarshallingTest,TestInt64Unparsing)927 TEST(MarshallingTest, TestInt64Unparsing) {
928   int64_t value;
929 
930   value = 1;
931   EXPECT_EQ(absl::UnparseFlag(value), "1");
932   value = 0;
933   EXPECT_EQ(absl::UnparseFlag(value), "0");
934   value = -1;
935   EXPECT_EQ(absl::UnparseFlag(value), "-1");
936   value = 123456789L;
937   EXPECT_EQ(absl::UnparseFlag(value), "123456789");
938   value = -987654321L;
939   EXPECT_EQ(absl::UnparseFlag(value), "-987654321");
940   value = 0x7FFFFFFFFFFFFFFF;
941   EXPECT_EQ(absl::UnparseFlag(value), "9223372036854775807");
942   value = 0xFFFFFFFFFFFFFFFF;
943   EXPECT_EQ(absl::UnparseFlag(value), "-1");
944 }
945 
946 // --------------------------------------------------------------------
947 
TEST(MarshallingTest,TestUint64Unparsing)948 TEST(MarshallingTest, TestUint64Unparsing) {
949   uint64_t value;
950 
951   value = 1;
952   EXPECT_EQ(absl::UnparseFlag(value), "1");
953   value = 0;
954   EXPECT_EQ(absl::UnparseFlag(value), "0");
955   value = 123456789L;
956   EXPECT_EQ(absl::UnparseFlag(value), "123456789");
957   value = 0xFFFFFFFFFFFFFFFF;
958   EXPECT_EQ(absl::UnparseFlag(value), "18446744073709551615");
959 }
960 
961 // --------------------------------------------------------------------
962 
TEST(MarshallingTest,TestInt128Unparsing)963 TEST(MarshallingTest, TestInt128Unparsing) {
964   absl::int128 value;
965 
966   value = 1;
967   EXPECT_EQ(absl::UnparseFlag(value), "1");
968   value = 0;
969   EXPECT_EQ(absl::UnparseFlag(value), "0");
970   value = -1;
971   EXPECT_EQ(absl::UnparseFlag(value), "-1");
972   value = 123456789L;
973   EXPECT_EQ(absl::UnparseFlag(value), "123456789");
974   value = -987654321L;
975   EXPECT_EQ(absl::UnparseFlag(value), "-987654321");
976   value = 0x7FFFFFFFFFFFFFFF;
977   EXPECT_EQ(absl::UnparseFlag(value), "9223372036854775807");
978 }
979 
980 // --------------------------------------------------------------------
981 
TEST(MarshallingTest,TestUint128Unparsing)982 TEST(MarshallingTest, TestUint128Unparsing) {
983   absl::uint128 value;
984 
985   value = 1;
986   EXPECT_EQ(absl::UnparseFlag(value), "1");
987   value = 0;
988   EXPECT_EQ(absl::UnparseFlag(value), "0");
989   value = 123456789L;
990   EXPECT_EQ(absl::UnparseFlag(value), "123456789");
991   value = absl::MakeUint128(0, 0xFFFFFFFFFFFFFFFF);
992   EXPECT_EQ(absl::UnparseFlag(value), "18446744073709551615");
993 }
994 
995 // --------------------------------------------------------------------
996 
TEST(MarshallingTest,TestFloatUnparsing)997 TEST(MarshallingTest, TestFloatUnparsing) {
998   float value;
999 
1000   value = 1.1f;
1001   EXPECT_EQ(absl::UnparseFlag(value), "1.1");
1002   value = 0.01f;
1003   EXPECT_EQ(absl::UnparseFlag(value), "0.01");
1004   value = 1.23e-2f;
1005   EXPECT_EQ(absl::UnparseFlag(value), "0.0123");
1006   value = -0.71f;
1007   EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
1008 }
1009 
1010 // --------------------------------------------------------------------
1011 
TEST(MarshallingTest,TestDoubleUnparsing)1012 TEST(MarshallingTest, TestDoubleUnparsing) {
1013   double value;
1014 
1015   value = 1.1;
1016   EXPECT_EQ(absl::UnparseFlag(value), "1.1");
1017   value = 0.01;
1018   EXPECT_EQ(absl::UnparseFlag(value), "0.01");
1019   value = 1.23e-2;
1020   EXPECT_EQ(absl::UnparseFlag(value), "0.0123");
1021   value = -0.71;
1022   EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
1023   value = -0;
1024   EXPECT_EQ(absl::UnparseFlag(value), "0");
1025   value = std::nan("");
1026   EXPECT_EQ(absl::UnparseFlag(value), "nan");
1027   value = std::numeric_limits<double>::infinity();
1028   EXPECT_EQ(absl::UnparseFlag(value), "inf");
1029 }
1030 
1031 // --------------------------------------------------------------------
1032 
TEST(MarshallingTest,TestStringUnparsing)1033 TEST(MarshallingTest, TestStringUnparsing) {
1034   EXPECT_EQ(absl::UnparseFlag(""), "");
1035   EXPECT_EQ(absl::UnparseFlag(" "), " ");
1036   EXPECT_EQ(absl::UnparseFlag("qwerty"), "qwerty");
1037   EXPECT_EQ(absl::UnparseFlag("ASDFGH"), "ASDFGH");
1038   EXPECT_EQ(absl::UnparseFlag("\n\t  "), "\n\t  ");
1039 }
1040 
1041 // --------------------------------------------------------------------
1042 
TEST(MarshallingTest,TestOptionalBoolUnparsing)1043 TEST(MarshallingTest, TestOptionalBoolUnparsing) {
1044   absl::optional<bool> value;
1045 
1046   EXPECT_EQ(absl::UnparseFlag(value), "");
1047   value = true;
1048   EXPECT_EQ(absl::UnparseFlag(value), "true");
1049   value = false;
1050   EXPECT_EQ(absl::UnparseFlag(value), "false");
1051   value = absl::nullopt;
1052   EXPECT_EQ(absl::UnparseFlag(value), "");
1053 }
1054 
1055 // --------------------------------------------------------------------
1056 
TEST(MarshallingTest,TestOptionalIntUnparsing)1057 TEST(MarshallingTest, TestOptionalIntUnparsing) {
1058   absl::optional<int> value;
1059 
1060   EXPECT_EQ(absl::UnparseFlag(value), "");
1061   value = 0;
1062   EXPECT_EQ(absl::UnparseFlag(value), "0");
1063   value = -12;
1064   EXPECT_EQ(absl::UnparseFlag(value), "-12");
1065   value = absl::nullopt;
1066   EXPECT_EQ(absl::UnparseFlag(value), "");
1067 }
1068 
1069 // --------------------------------------------------------------------
1070 
TEST(MarshallingTest,TestOptionalDoubleUnparsing)1071 TEST(MarshallingTest, TestOptionalDoubleUnparsing) {
1072   absl::optional<double> value;
1073 
1074   EXPECT_EQ(absl::UnparseFlag(value), "");
1075   value = 1.;
1076   EXPECT_EQ(absl::UnparseFlag(value), "1");
1077   value = -1.23;
1078   EXPECT_EQ(absl::UnparseFlag(value), "-1.23");
1079   value = absl::nullopt;
1080   EXPECT_EQ(absl::UnparseFlag(value), "");
1081 }
1082 
1083 // --------------------------------------------------------------------
1084 
TEST(MarshallingTest,TestOptionalStringUnparsing)1085 TEST(MarshallingTest, TestOptionalStringUnparsing) {
1086   absl::optional<std::string> strvalue;
1087   EXPECT_EQ(absl::UnparseFlag(strvalue), "");
1088 
1089   strvalue = "asdfg";
1090   EXPECT_EQ(absl::UnparseFlag(strvalue), "asdfg");
1091 
1092   strvalue = " ";
1093   EXPECT_EQ(absl::UnparseFlag(strvalue), " ");
1094 
1095   strvalue = "";  // It is UB to set an optional string flag to ""
1096   EXPECT_EQ(absl::UnparseFlag(strvalue), "");
1097 }
1098 
1099 // --------------------------------------------------------------------
1100 
1101 #if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
1102 
TEST(MarshallingTest,TestStdOptionalUnparsing)1103 TEST(MarshallingTest, TestStdOptionalUnparsing) {
1104   std::optional<std::string> strvalue;
1105   EXPECT_EQ(absl::UnparseFlag(strvalue), "");
1106 
1107   strvalue = "asdfg";
1108   EXPECT_EQ(absl::UnparseFlag(strvalue), "asdfg");
1109 
1110   strvalue = " ";
1111   EXPECT_EQ(absl::UnparseFlag(strvalue), " ");
1112 
1113   strvalue = "";  // It is UB to set an optional string flag to ""
1114   EXPECT_EQ(absl::UnparseFlag(strvalue), "");
1115 
1116   std::optional<int> intvalue;
1117   EXPECT_EQ(absl::UnparseFlag(intvalue), "");
1118 
1119   intvalue = 10;
1120   EXPECT_EQ(absl::UnparseFlag(intvalue), "10");
1121 }
1122 
1123 // --------------------------------------------------------------------
1124 
1125 #endif
1126 
1127 template <typename T>
TestRoundtrip(T v)1128 void TestRoundtrip(T v) {
1129   T new_v;
1130   std::string err;
1131   EXPECT_TRUE(absl::ParseFlag(absl::UnparseFlag(v), &new_v, &err));
1132   EXPECT_EQ(new_v, v);
1133 }
1134 
TEST(MarshallingTest,TestFloatRoundTrip)1135 TEST(MarshallingTest, TestFloatRoundTrip) {
1136   TestRoundtrip(0.1f);
1137   TestRoundtrip(0.12f);
1138   TestRoundtrip(0.123f);
1139   TestRoundtrip(0.1234f);
1140   TestRoundtrip(0.12345f);
1141   TestRoundtrip(0.123456f);
1142   TestRoundtrip(0.1234567f);
1143   TestRoundtrip(0.12345678f);
1144 
1145   TestRoundtrip(0.1e20f);
1146   TestRoundtrip(0.12e20f);
1147   TestRoundtrip(0.123e20f);
1148   TestRoundtrip(0.1234e20f);
1149   TestRoundtrip(0.12345e20f);
1150   TestRoundtrip(0.123456e20f);
1151   TestRoundtrip(0.1234567e20f);
1152   TestRoundtrip(0.12345678e20f);
1153 
1154   TestRoundtrip(0.1e-20f);
1155   TestRoundtrip(0.12e-20f);
1156   TestRoundtrip(0.123e-20f);
1157   TestRoundtrip(0.1234e-20f);
1158   TestRoundtrip(0.12345e-20f);
1159   TestRoundtrip(0.123456e-20f);
1160   TestRoundtrip(0.1234567e-20f);
1161   TestRoundtrip(0.12345678e-20f);
1162 }
1163 
TEST(MarshallingTest,TestDoubleRoundTrip)1164 TEST(MarshallingTest, TestDoubleRoundTrip) {
1165   TestRoundtrip(0.1);
1166   TestRoundtrip(0.12);
1167   TestRoundtrip(0.123);
1168   TestRoundtrip(0.1234);
1169   TestRoundtrip(0.12345);
1170   TestRoundtrip(0.123456);
1171   TestRoundtrip(0.1234567);
1172   TestRoundtrip(0.12345678);
1173   TestRoundtrip(0.123456789);
1174   TestRoundtrip(0.1234567891);
1175   TestRoundtrip(0.12345678912);
1176   TestRoundtrip(0.123456789123);
1177   TestRoundtrip(0.1234567891234);
1178   TestRoundtrip(0.12345678912345);
1179   TestRoundtrip(0.123456789123456);
1180   TestRoundtrip(0.1234567891234567);
1181   TestRoundtrip(0.12345678912345678);
1182 
1183   TestRoundtrip(0.1e50);
1184   TestRoundtrip(0.12e50);
1185   TestRoundtrip(0.123e50);
1186   TestRoundtrip(0.1234e50);
1187   TestRoundtrip(0.12345e50);
1188   TestRoundtrip(0.123456e50);
1189   TestRoundtrip(0.1234567e50);
1190   TestRoundtrip(0.12345678e50);
1191   TestRoundtrip(0.123456789e50);
1192   TestRoundtrip(0.1234567891e50);
1193   TestRoundtrip(0.12345678912e50);
1194   TestRoundtrip(0.123456789123e50);
1195   TestRoundtrip(0.1234567891234e50);
1196   TestRoundtrip(0.12345678912345e50);
1197   TestRoundtrip(0.123456789123456e50);
1198   TestRoundtrip(0.1234567891234567e50);
1199   TestRoundtrip(0.12345678912345678e50);
1200 
1201   TestRoundtrip(0.1e-50);
1202   TestRoundtrip(0.12e-50);
1203   TestRoundtrip(0.123e-50);
1204   TestRoundtrip(0.1234e-50);
1205   TestRoundtrip(0.12345e-50);
1206   TestRoundtrip(0.123456e-50);
1207   TestRoundtrip(0.1234567e-50);
1208   TestRoundtrip(0.12345678e-50);
1209   TestRoundtrip(0.123456789e-50);
1210   TestRoundtrip(0.1234567891e-50);
1211   TestRoundtrip(0.12345678912e-50);
1212   TestRoundtrip(0.123456789123e-50);
1213   TestRoundtrip(0.1234567891234e-50);
1214   TestRoundtrip(0.12345678912345e-50);
1215   TestRoundtrip(0.123456789123456e-50);
1216   TestRoundtrip(0.1234567891234567e-50);
1217   TestRoundtrip(0.12345678912345678e-50);
1218 }
1219 
1220 }  // namespace
1221