xref: /aosp_15_r20/external/emboss/runtime/cpp/test/emboss_text_util_test.cc (revision 99e0aae7469b87d12f0ad23e61142c2d74c1ef70) 
1 // Copyright 2019 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include "runtime/cpp/emboss_text_util.h"
16 
17 #include <cmath>
18 #include <limits>
19 
20 #include "gtest/gtest.h"
21 
22 namespace emboss {
23 namespace support {
24 namespace test {
25 
TEST(DecodeInteger,DecodeUInt8Decimal)26 TEST(DecodeInteger, DecodeUInt8Decimal) {
27   ::std::uint8_t result;
28   EXPECT_TRUE(DecodeInteger("123", &result));
29   EXPECT_EQ(123, result);
30   EXPECT_TRUE(DecodeInteger("0", &result));
31   EXPECT_EQ(0, result);
32   EXPECT_TRUE(DecodeInteger("0123", &result));
33   EXPECT_EQ(123, result);
34   EXPECT_TRUE(DecodeInteger("0_123", &result));
35   EXPECT_EQ(123, result);
36   EXPECT_FALSE(DecodeInteger("_12", &result));
37   EXPECT_EQ(123, result);
38   EXPECT_FALSE(DecodeInteger("1234", &result));
39   EXPECT_EQ(123, result);
40   EXPECT_FALSE(DecodeInteger("12a", &result));
41   EXPECT_EQ(123, result);
42   EXPECT_FALSE(DecodeInteger("12A", &result));
43   EXPECT_EQ(123, result);
44   EXPECT_FALSE(DecodeInteger("12 ", &result));
45   EXPECT_EQ(123, result);
46   EXPECT_FALSE(DecodeInteger(" 12", &result));
47   EXPECT_EQ(123, result);
48   EXPECT_FALSE(DecodeInteger("12.", &result));
49   EXPECT_EQ(123, result);
50   EXPECT_FALSE(DecodeInteger("12.0", &result));
51   EXPECT_EQ(123, result);
52   EXPECT_FALSE(DecodeInteger("256", &result));
53   EXPECT_EQ(123, result);
54   EXPECT_TRUE(DecodeInteger("128", &result));
55   EXPECT_EQ(128, result);
56   EXPECT_FALSE(DecodeInteger("-0", &result));
57   EXPECT_EQ(128, result);
58   EXPECT_TRUE(DecodeInteger("255", &result));
59   EXPECT_EQ(255, result);
60 }
61 
TEST(DecodeInteger,DecodeInt8Decimal)62 TEST(DecodeInteger, DecodeInt8Decimal) {
63   ::std::int8_t result;
64   EXPECT_TRUE(DecodeInteger("123", &result));
65   EXPECT_EQ(123, result);
66   EXPECT_TRUE(DecodeInteger("0", &result));
67   EXPECT_EQ(0, result);
68   EXPECT_TRUE(DecodeInteger("0123", &result));
69   EXPECT_EQ(123, result);
70   EXPECT_TRUE(DecodeInteger("0_123", &result));
71   EXPECT_EQ(123, result);
72   EXPECT_FALSE(DecodeInteger("_12", &result));
73   EXPECT_EQ(123, result);
74   EXPECT_FALSE(DecodeInteger("1234", &result));
75   EXPECT_EQ(123, result);
76   EXPECT_FALSE(DecodeInteger("12a", &result));
77   EXPECT_EQ(123, result);
78   EXPECT_FALSE(DecodeInteger("12A", &result));
79   EXPECT_EQ(123, result);
80   EXPECT_FALSE(DecodeInteger("12 ", &result));
81   EXPECT_EQ(123, result);
82   EXPECT_FALSE(DecodeInteger(" 12", &result));
83   EXPECT_EQ(123, result);
84   EXPECT_FALSE(DecodeInteger("12.", &result));
85   EXPECT_EQ(123, result);
86   EXPECT_FALSE(DecodeInteger("12.0", &result));
87   EXPECT_EQ(123, result);
88   EXPECT_FALSE(DecodeInteger("256", &result));
89   EXPECT_EQ(123, result);
90   EXPECT_FALSE(DecodeInteger("128", &result));
91   EXPECT_EQ(123, result);
92   EXPECT_TRUE(DecodeInteger("-0", &result));
93   EXPECT_EQ(0, result);
94   EXPECT_TRUE(DecodeInteger("127", &result));
95   EXPECT_EQ(127, result);
96   EXPECT_TRUE(DecodeInteger("-127", &result));
97   EXPECT_EQ(-127, result);
98   EXPECT_TRUE(DecodeInteger("-128", &result));
99   EXPECT_EQ(-128, result);
100   EXPECT_FALSE(DecodeInteger("0-127", &result));
101   EXPECT_EQ(-128, result);
102   EXPECT_FALSE(DecodeInteger("- 127", &result));
103   EXPECT_EQ(-128, result);
104 }
105 
TEST(DecodeInteger,DecodeUInt8Hex)106 TEST(DecodeInteger, DecodeUInt8Hex) {
107   ::std::uint8_t result;
108   EXPECT_TRUE(DecodeInteger("0x23", &result));
109   EXPECT_EQ(0x23, result);
110   EXPECT_TRUE(DecodeInteger("0x0", &result));
111   EXPECT_EQ(0x0, result);
112   EXPECT_TRUE(DecodeInteger("0xff", &result));
113   EXPECT_EQ(0xff, result);
114   EXPECT_TRUE(DecodeInteger("0xFE", &result));
115   EXPECT_EQ(0xfe, result);
116   EXPECT_TRUE(DecodeInteger("0xFd", &result));
117   EXPECT_EQ(0xfd, result);
118   EXPECT_TRUE(DecodeInteger("0XeC", &result));
119   EXPECT_EQ(0xec, result);
120   EXPECT_TRUE(DecodeInteger("0x012", &result));
121   EXPECT_EQ(0x12, result);
122   EXPECT_TRUE(DecodeInteger("0x0_0023", &result));
123   EXPECT_EQ(0x23, result);
124   EXPECT_TRUE(DecodeInteger("0x_0023", &result));
125   EXPECT_EQ(0x23, result);
126   EXPECT_FALSE(DecodeInteger("0x100", &result));
127   EXPECT_EQ(0x23, result);
128   EXPECT_FALSE(DecodeInteger("0x", &result));
129   EXPECT_EQ(0x23, result);
130   EXPECT_FALSE(DecodeInteger("0x0x0", &result));
131   EXPECT_EQ(0x23, result);
132   EXPECT_FALSE(DecodeInteger("0x1g", &result));
133   EXPECT_EQ(0x23, result);
134 }
135 
TEST(DecodeInteger,DecodeUInt8Binary)136 TEST(DecodeInteger, DecodeUInt8Binary) {
137   ::std::uint8_t result;
138   EXPECT_TRUE(DecodeInteger("0b10100101", &result));
139   EXPECT_EQ(0xa5, result);
140   EXPECT_TRUE(DecodeInteger("0b0", &result));
141   EXPECT_EQ(0x0, result);
142   EXPECT_TRUE(DecodeInteger("0B1", &result));
143   EXPECT_EQ(0x1, result);
144   EXPECT_TRUE(DecodeInteger("0b11111111", &result));
145   EXPECT_EQ(0xff, result);
146   EXPECT_TRUE(DecodeInteger("0b011111110", &result));
147   EXPECT_EQ(0xfe, result);
148   EXPECT_TRUE(DecodeInteger("0b00_0010_0011", &result));
149   EXPECT_EQ(0x23, result);
150   EXPECT_TRUE(DecodeInteger("0b_0010_0011", &result));
151   EXPECT_EQ(0x23, result);
152   EXPECT_FALSE(DecodeInteger("0b100000000", &result));
153   EXPECT_EQ(0x23, result);
154   EXPECT_FALSE(DecodeInteger("0b", &result));
155   EXPECT_EQ(0x23, result);
156   EXPECT_FALSE(DecodeInteger("0b0b0", &result));
157   EXPECT_EQ(0x23, result);
158   EXPECT_FALSE(DecodeInteger("0b12", &result));
159   EXPECT_EQ(0x23, result);
160   EXPECT_FALSE(DecodeInteger("-0b0", &result));
161   EXPECT_EQ(0x23, result);
162 }
163 
TEST(DecodeInteger,DecodeInt8Binary)164 TEST(DecodeInteger, DecodeInt8Binary) {
165   ::std::int8_t result;
166   EXPECT_TRUE(DecodeInteger("0b01011010", &result));
167   EXPECT_EQ(0x5a, result);
168   EXPECT_TRUE(DecodeInteger("0b0", &result));
169   EXPECT_EQ(0x0, result);
170   EXPECT_TRUE(DecodeInteger("0B1", &result));
171   EXPECT_EQ(0x1, result);
172   EXPECT_TRUE(DecodeInteger("0b1111111", &result));
173   EXPECT_EQ(0x7f, result);
174   EXPECT_TRUE(DecodeInteger("0b01111110", &result));
175   EXPECT_EQ(0x7e, result);
176   EXPECT_TRUE(DecodeInteger("0b00_0010_0011", &result));
177   EXPECT_EQ(0x23, result);
178   EXPECT_TRUE(DecodeInteger("0b_0010_0011", &result));
179   EXPECT_EQ(0x23, result);
180   EXPECT_FALSE(DecodeInteger("0b100000000", &result));
181   EXPECT_EQ(0x23, result);
182   EXPECT_FALSE(DecodeInteger("0b", &result));
183   EXPECT_EQ(0x23, result);
184   EXPECT_FALSE(DecodeInteger("-0b", &result));
185   EXPECT_EQ(0x23, result);
186   EXPECT_FALSE(DecodeInteger("0b0b0", &result));
187   EXPECT_EQ(0x23, result);
188   EXPECT_FALSE(DecodeInteger("0b12", &result));
189   EXPECT_EQ(0x23, result);
190   EXPECT_FALSE(DecodeInteger("0b10000000", &result));
191   EXPECT_EQ(0x23, result);
192   EXPECT_TRUE(DecodeInteger("-0b1111111", &result));
193   EXPECT_EQ(-0x7f, result);
194   EXPECT_TRUE(DecodeInteger("-0b10000000", &result));
195   EXPECT_EQ(-0x80, result);
196   EXPECT_FALSE(DecodeInteger("-0b10000001", &result));
197   EXPECT_EQ(-0x80, result);
198   EXPECT_TRUE(DecodeInteger("-0b0", &result));
199   EXPECT_EQ(0x0, result);
200 }
201 
TEST(DecodeInteger,DecodeUInt16)202 TEST(DecodeInteger, DecodeUInt16) {
203   ::std::uint16_t result;
204   EXPECT_TRUE(DecodeInteger("65535", &result));
205   EXPECT_EQ(65535, result);
206   EXPECT_FALSE(DecodeInteger("65536", &result));
207   EXPECT_EQ(65535, result);
208 }
209 
TEST(DecodeInteger,DecodeInt16)210 TEST(DecodeInteger, DecodeInt16) {
211   ::std::int16_t result;
212   EXPECT_TRUE(DecodeInteger("32767", &result));
213   EXPECT_EQ(32767, result);
214   EXPECT_FALSE(DecodeInteger("32768", &result));
215   EXPECT_EQ(32767, result);
216   EXPECT_TRUE(DecodeInteger("-32768", &result));
217   EXPECT_EQ(-32768, result);
218   EXPECT_FALSE(DecodeInteger("-32769", &result));
219   EXPECT_EQ(-32768, result);
220 }
221 
TEST(DecodeInteger,DecodeUInt32)222 TEST(DecodeInteger, DecodeUInt32) {
223   ::std::uint32_t result;
224   EXPECT_TRUE(DecodeInteger("4294967295", &result));
225   EXPECT_EQ(4294967295U, result);
226   EXPECT_FALSE(DecodeInteger("4294967296", &result));
227   EXPECT_EQ(4294967295U, result);
228 }
229 
TEST(DecodeInteger,DecodeInt32)230 TEST(DecodeInteger, DecodeInt32) {
231   ::std::int32_t result;
232   EXPECT_TRUE(DecodeInteger("2147483647", &result));
233   EXPECT_EQ(2147483647, result);
234   EXPECT_FALSE(DecodeInteger("2147483648", &result));
235   EXPECT_EQ(2147483647, result);
236   EXPECT_FALSE(DecodeInteger("4294967295", &result));
237   EXPECT_EQ(2147483647, result);
238   EXPECT_TRUE(DecodeInteger("-2147483648", &result));
239   EXPECT_EQ(-2147483647 - 1, result);
240   EXPECT_FALSE(DecodeInteger("-2147483649", &result));
241   EXPECT_EQ(-2147483647 - 1, result);
242 }
243 
TEST(DecodeInteger,DecodeUInt64)244 TEST(DecodeInteger, DecodeUInt64) {
245   ::std::uint64_t result;
246   EXPECT_TRUE(DecodeInteger("18446744073709551615", &result));
247   EXPECT_EQ(18446744073709551615ULL, result);
248   EXPECT_FALSE(DecodeInteger("18446744073709551616", &result));
249   EXPECT_EQ(18446744073709551615ULL, result);
250 }
251 
TEST(DecodeInteger,DecodeInt64)252 TEST(DecodeInteger, DecodeInt64) {
253   ::std::int64_t result;
254   EXPECT_TRUE(DecodeInteger("9223372036854775807", &result));
255   EXPECT_EQ(9223372036854775807LL, result);
256   EXPECT_FALSE(DecodeInteger("9223372036854775808", &result));
257   EXPECT_EQ(9223372036854775807LL, result);
258   EXPECT_FALSE(DecodeInteger("18446744073709551615", &result));
259   EXPECT_EQ(9223372036854775807LL, result);
260   EXPECT_TRUE(DecodeInteger("-9223372036854775808", &result));
261   EXPECT_EQ(-9223372036854775807LL - 1LL, result);
262   EXPECT_FALSE(DecodeInteger("-9223372036854775809", &result));
263   EXPECT_EQ(-9223372036854775807LL - 1LL, result);
264 }
265 
TEST(TextStream,Construction)266 TEST(TextStream, Construction) {
267   ::std::string string_text = "ab";
268   auto text_stream = TextStream(string_text);
269   char result;
270   EXPECT_TRUE(text_stream.Read(&result));
271   EXPECT_EQ('a', result);
272   EXPECT_TRUE(text_stream.Read(&result));
273   EXPECT_EQ('b', result);
274   EXPECT_FALSE(text_stream.Read(&result));
275 
276   const char *c_string = "cd";
277   text_stream = TextStream(c_string);
278   EXPECT_TRUE(text_stream.Read(&result));
279   EXPECT_EQ('c', result);
280   EXPECT_TRUE(text_stream.Read(&result));
281   EXPECT_EQ('d', result);
282   EXPECT_FALSE(text_stream.Read(&result));
283 
284   const char *long_c_string = "efghi";
285   text_stream = TextStream(long_c_string, 2);
286   EXPECT_TRUE(text_stream.Read(&result));
287   EXPECT_EQ('e', result);
288   EXPECT_TRUE(text_stream.Read(&result));
289   EXPECT_EQ('f', result);
290   EXPECT_FALSE(text_stream.Read(&result));
291 }
292 
TEST(TextStream,Methods)293 TEST(TextStream, Methods) {
294   auto text_stream = TextStream{"abc"};
295 
296   EXPECT_FALSE(text_stream.Unread('d'));
297   char result;
298   EXPECT_TRUE(text_stream.Read(&result));
299   EXPECT_EQ('a', result);
300 
301   EXPECT_FALSE(text_stream.Unread('e'));
302   EXPECT_TRUE(text_stream.Read(&result));
303   EXPECT_EQ('b', result);
304 
305   EXPECT_TRUE(text_stream.Unread('b'));
306   result = 'f';
307   EXPECT_TRUE(text_stream.Read(&result));
308   EXPECT_EQ('b', result);
309 
310   EXPECT_TRUE(text_stream.Read(&result));
311   EXPECT_EQ('c', result);
312 
313   result = 'g';
314   EXPECT_FALSE(text_stream.Read(&result));
315   EXPECT_EQ('g', result);
316 
317   auto empty_text_stream = TextStream{""};
318   EXPECT_FALSE(empty_text_stream.Read(&result));
319   EXPECT_EQ('g', result);
320 }
321 
TEST(ReadToken,ReadsToken)322 TEST(ReadToken, ReadsToken) {
323   auto text_stream = TextStream{"abc"};
324   ::std::string result;
325   EXPECT_TRUE(ReadToken(&text_stream, &result));
326   EXPECT_EQ("abc", result);
327   EXPECT_TRUE(ReadToken(&text_stream, &result));
328   EXPECT_EQ("", result);
329   EXPECT_TRUE(ReadToken(&text_stream, &result));
330   EXPECT_EQ("", result);
331 }
332 
TEST(ReadToken,ReadsTwoTokens)333 TEST(ReadToken, ReadsTwoTokens) {
334   auto text_stream = TextStream{"abc def"};
335   ::std::string result;
336   EXPECT_TRUE(ReadToken(&text_stream, &result));
337   EXPECT_EQ("abc", result);
338   EXPECT_TRUE(ReadToken(&text_stream, &result));
339   EXPECT_EQ("def", result);
340   EXPECT_TRUE(ReadToken(&text_stream, &result));
341   EXPECT_EQ("", result);
342 }
343 
TEST(ReadToken,SkipsInitialWhitespace)344 TEST(ReadToken, SkipsInitialWhitespace) {
345   auto text_stream = TextStream{"  \t\r\r\n\t\r  abc def"};
346   ::std::string result;
347   EXPECT_TRUE(ReadToken(&text_stream, &result));
348   EXPECT_EQ("abc", result);
349   EXPECT_TRUE(ReadToken(&text_stream, &result));
350   EXPECT_EQ("def", result);
351   EXPECT_TRUE(ReadToken(&text_stream, &result));
352   EXPECT_EQ("", result);
353 }
354 
TEST(ReadToken,SkipsComments)355 TEST(ReadToken, SkipsComments) {
356   auto text_stream = TextStream{"  #comment##\r#comment\n abc #c\n  def"};
357   ::std::string result;
358   EXPECT_TRUE(ReadToken(&text_stream, &result));
359   EXPECT_EQ("abc", result);
360   EXPECT_TRUE(ReadToken(&text_stream, &result));
361   EXPECT_EQ("def", result);
362   EXPECT_TRUE(ReadToken(&text_stream, &result));
363   EXPECT_EQ("", result);
364 }
365 
TEST(TextOutputOptions,Defaults)366 TEST(TextOutputOptions, Defaults) {
367   TextOutputOptions options;
368   EXPECT_EQ("", options.current_indent());
369   EXPECT_EQ("", options.indent());
370   EXPECT_FALSE(options.multiline());
371   EXPECT_FALSE(options.comments());
372   EXPECT_FALSE(options.digit_grouping());
373   EXPECT_EQ(10, options.numeric_base());
374 }
375 
TEST(TextOutputOptions,WithIndent)376 TEST(TextOutputOptions, WithIndent) {
377   TextOutputOptions options;
378   TextOutputOptions new_options = options.WithIndent("xyz");
379   EXPECT_EQ("", options.current_indent());
380   EXPECT_EQ("", options.indent());
381   EXPECT_EQ("", new_options.current_indent());
382   EXPECT_EQ("xyz", new_options.indent());
383 }
384 
TEST(TextOutputOptions,PlusOneIndent)385 TEST(TextOutputOptions, PlusOneIndent) {
386   TextOutputOptions options;
387   TextOutputOptions new_options = options.WithIndent("xyz").PlusOneIndent();
388   EXPECT_EQ("", options.current_indent());
389   EXPECT_EQ("", options.indent());
390   EXPECT_EQ("xyz", new_options.current_indent());
391   EXPECT_EQ("xyz", new_options.indent());
392   EXPECT_EQ("xyzxyz", new_options.PlusOneIndent().current_indent());
393 }
394 
TEST(TextOutputOptions,WithComments)395 TEST(TextOutputOptions, WithComments) {
396   TextOutputOptions options;
397   TextOutputOptions new_options = options.WithComments(true);
398   EXPECT_FALSE(options.comments());
399   EXPECT_TRUE(new_options.comments());
400 }
401 
TEST(TextOutputOptions,WithDigitGrouping)402 TEST(TextOutputOptions, WithDigitGrouping) {
403   TextOutputOptions options;
404   TextOutputOptions new_options = options.WithDigitGrouping(true);
405   EXPECT_FALSE(options.digit_grouping());
406   EXPECT_TRUE(new_options.digit_grouping());
407 }
408 
TEST(TextOutputOptions,Multiline)409 TEST(TextOutputOptions, Multiline) {
410   TextOutputOptions options;
411   TextOutputOptions new_options = options.Multiline(true);
412   EXPECT_FALSE(options.multiline());
413   EXPECT_TRUE(new_options.multiline());
414 }
415 
TEST(TextOutputOptions,WithNumericBase)416 TEST(TextOutputOptions, WithNumericBase) {
417   TextOutputOptions options;
418   TextOutputOptions new_options = options.WithNumericBase(2);
419   EXPECT_EQ(10, options.numeric_base());
420   EXPECT_EQ(2, new_options.numeric_base());
421 }
422 
TEST(TextOutputOptions,WithAllowPartialOutput)423 TEST(TextOutputOptions, WithAllowPartialOutput) {
424   TextOutputOptions options;
425   TextOutputOptions new_options = options.WithAllowPartialOutput(true);
426   EXPECT_FALSE(options.allow_partial_output());
427   EXPECT_TRUE(new_options.allow_partial_output());
428 }
429 
430 // Small helper function for the various WriteIntegerToTextStream tests; just
431 // sets up a stream, forwards its arguments to WriteIntegerToTextStream, and
432 // then returns the text from the stream.
433 template <typename Arg0, typename... Args>
WriteIntegerToString(Arg0 && arg0,Args &&...args)434 ::std::string WriteIntegerToString(Arg0 &&arg0, Args &&... args) {
435   TextOutputStream stream;
436   WriteIntegerToTextStream(::std::forward<Arg0>(arg0), &stream,
437                            ::std::forward<Args>(args)...);
438   return stream.Result();
439 }
440 
TEST(WriteIntegerToTextStream,Decimal)441 TEST(WriteIntegerToTextStream, Decimal) {
442   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(0), 10,
443                                       false));
444   EXPECT_EQ("100", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(100),
445                                         10, false));
446   EXPECT_EQ("255", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(255),
447                                         10, false));
448   EXPECT_EQ("-128", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-128),
449                                          10, false));
450   EXPECT_EQ("-100", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-100),
451                                          10, false));
452   EXPECT_EQ(
453       "0", WriteIntegerToString(static_cast</**/ ::std::int8_t>(0), 10, false));
454   EXPECT_EQ("100", WriteIntegerToString(static_cast</**/ ::std::int8_t>(100),
455                                         10, false));
456   EXPECT_EQ("127", WriteIntegerToString(static_cast</**/ ::std::int8_t>(127),
457                                         10, false));
458 
459   EXPECT_EQ(
460       "0", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(0), 10, true));
461   EXPECT_EQ("100", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(100),
462                                         10, true));
463   EXPECT_EQ("255", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(255),
464                                         10, true));
465   EXPECT_EQ("-128", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-128),
466                                          10, true));
467   EXPECT_EQ("-100", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-100),
468                                          10, true));
469   EXPECT_EQ("0",
470             WriteIntegerToString(static_cast</**/ ::std::int8_t>(0), 10, true));
471   EXPECT_EQ("100", WriteIntegerToString(static_cast</**/ ::std::int8_t>(100),
472                                         10, true));
473   EXPECT_EQ("127", WriteIntegerToString(static_cast</**/ ::std::int8_t>(127),
474                                         10, true));
475 
476   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::uint16_t>(0), 10,
477                                       false));
478   EXPECT_EQ("1000", WriteIntegerToString(
479                         static_cast</**/ ::std::uint16_t>(1000), 10, false));
480   EXPECT_EQ("65535", WriteIntegerToString(
481                          static_cast</**/ ::std::uint16_t>(65535), 10, false));
482   EXPECT_EQ("-32768", WriteIntegerToString(
483                           static_cast</**/ ::std::int16_t>(-32768), 10, false));
484   EXPECT_EQ("-10000", WriteIntegerToString(
485                           static_cast</**/ ::std::int16_t>(-10000), 10, false));
486   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::int16_t>(0), 10,
487                                       false));
488   EXPECT_EQ("32767", WriteIntegerToString(
489                          static_cast</**/ ::std::int16_t>(32767), 10, false));
490 
491   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::uint16_t>(0), 10,
492                                       true));
493   EXPECT_EQ("999", WriteIntegerToString(static_cast</**/ ::std::uint16_t>(999),
494                                         10, true));
495   EXPECT_EQ("1_000", WriteIntegerToString(
496                          static_cast</**/ ::std::uint16_t>(1000), 10, true));
497   EXPECT_EQ("65_535", WriteIntegerToString(
498                           static_cast</**/ ::std::uint16_t>(65535), 10, true));
499   EXPECT_EQ("-32_768", WriteIntegerToString(
500                            static_cast</**/ ::std::int16_t>(-32768), 10, true));
501   EXPECT_EQ("-1_000", WriteIntegerToString(
502                           static_cast</**/ ::std::int16_t>(-1000), 10, true));
503   EXPECT_EQ("-999", WriteIntegerToString(static_cast</**/ ::std::int16_t>(-999),
504                                          10, true));
505   EXPECT_EQ(
506       "0", WriteIntegerToString(static_cast</**/ ::std::int16_t>(0), 10, true));
507   EXPECT_EQ("32_767", WriteIntegerToString(
508                           static_cast</**/ ::std::int16_t>(32767), 10, true));
509 
510   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::uint32_t>(0), 10,
511                                       false));
512   EXPECT_EQ("1000000",
513             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(1000000), 10,
514                                  false));
515   EXPECT_EQ("4294967295",
516             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(4294967295),
517                                  10, false));
518   EXPECT_EQ("-2147483648",
519             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-2147483648),
520                                  10, false));
521   EXPECT_EQ("-100000",
522             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-100000), 10,
523                                  false));
524   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::int32_t>(0), 10,
525                                       false));
526   EXPECT_EQ("2147483647",
527             WriteIntegerToString(static_cast</**/ ::std::int32_t>(2147483647),
528                                  10, false));
529 
530   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::uint32_t>(0), 10,
531                                       true));
532   EXPECT_EQ("999_999",
533             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(999999), 10,
534                                  true));
535   EXPECT_EQ("1_000_000",
536             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(1000000), 10,
537                                  true));
538   EXPECT_EQ("4_294_967_295",
539             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(4294967295U),
540                                  10, true));
541   EXPECT_EQ("-2_147_483_648",
542             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-2147483648L),
543                                  10, true));
544   EXPECT_EQ("-999_999",
545             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-999999), 10,
546                                  true));
547   EXPECT_EQ("-1_000_000",
548             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-1000000), 10,
549                                  true));
550   EXPECT_EQ(
551       "0", WriteIntegerToString(static_cast</**/ ::std::int32_t>(0), 10, true));
552   EXPECT_EQ("2_147_483_647",
553             WriteIntegerToString(static_cast</**/ ::std::int32_t>(2147483647),
554                                  10, true));
555 
556   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::uint64_t>(0), 10,
557                                       false));
558   EXPECT_EQ("1000000",
559             WriteIntegerToString(static_cast</**/ ::std::uint64_t>(1000000), 10,
560                                  false));
561   EXPECT_EQ("18446744073709551615",
562             WriteIntegerToString(
563                 static_cast</**/ ::std::uint64_t>(18446744073709551615UL), 10,
564                 false));
565   EXPECT_EQ("-9223372036854775808",
566             WriteIntegerToString(
567                 static_cast</**/ ::std::int64_t>(-9223372036854775807L - 1), 10,
568                 false));
569   EXPECT_EQ("-100000",
570             WriteIntegerToString(static_cast</**/ ::std::int64_t>(-100000), 10,
571                                  false));
572   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::int64_t>(0), 10,
573                                       false));
574   EXPECT_EQ(
575       "9223372036854775807",
576       WriteIntegerToString(
577           static_cast</**/ ::std::int64_t>(9223372036854775807L), 10, false));
578 
579   EXPECT_EQ("0", WriteIntegerToString(static_cast</**/ ::std::uint64_t>(0), 10,
580                                       true));
581   EXPECT_EQ("1_000_000",
582             WriteIntegerToString(static_cast</**/ ::std::uint64_t>(1000000), 10,
583                                  true));
584   EXPECT_EQ(
585       "18_446_744_073_709_551_615",
586       WriteIntegerToString(
587           static_cast</**/ ::std::uint64_t>(18446744073709551615UL), 10, true));
588   EXPECT_EQ("-9_223_372_036_854_775_808",
589             WriteIntegerToString(
590                 static_cast</**/ ::std::int64_t>(-9223372036854775807L - 1), 10,
591                 true));
592   EXPECT_EQ("-100_000",
593             WriteIntegerToString(static_cast</**/ ::std::int64_t>(-100000), 10,
594                                  true));
595   EXPECT_EQ(
596       "0", WriteIntegerToString(static_cast</**/ ::std::int64_t>(0), 10, true));
597   EXPECT_EQ(
598       "9_223_372_036_854_775_807",
599       WriteIntegerToString(
600           static_cast</**/ ::std::int64_t>(9223372036854775807L), 10, true));
601 }
602 
TEST(WriteIntegerToTextStream,Binary)603 TEST(WriteIntegerToTextStream, Binary) {
604   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(0), 2,
605                                         false));
606   EXPECT_EQ("0b1100100", WriteIntegerToString(
607                              static_cast</**/ ::std::uint8_t>(100), 2, false));
608   EXPECT_EQ("0b11111111", WriteIntegerToString(
609                               static_cast</**/ ::std::uint8_t>(255), 2, false));
610   EXPECT_EQ(
611       "-0b10000000",
612       WriteIntegerToString(static_cast</**/ ::std::int8_t>(-128), 2, false));
613   EXPECT_EQ("-0b1100100", WriteIntegerToString(
614                               static_cast</**/ ::std::int8_t>(-100), 2, false));
615   EXPECT_EQ("0b0",
616             WriteIntegerToString(static_cast</**/ ::std::int8_t>(0), 2, false));
617   EXPECT_EQ("0b1100100", WriteIntegerToString(
618                              static_cast</**/ ::std::int8_t>(100), 2, false));
619   EXPECT_EQ("0b1111111", WriteIntegerToString(
620                              static_cast</**/ ::std::int8_t>(127), 2, false));
621 
622   EXPECT_EQ("0b0",
623             WriteIntegerToString(static_cast</**/ ::std::uint8_t>(0), 2, true));
624   EXPECT_EQ("0b1100100", WriteIntegerToString(
625                              static_cast</**/ ::std::uint8_t>(100), 2, true));
626   EXPECT_EQ("0b11111111", WriteIntegerToString(
627                               static_cast</**/ ::std::uint8_t>(255), 2, true));
628   EXPECT_EQ("-0b10000000", WriteIntegerToString(
629                                static_cast</**/ ::std::int8_t>(-128), 2, true));
630   EXPECT_EQ("-0b1100100", WriteIntegerToString(
631                               static_cast</**/ ::std::int8_t>(-100), 2, true));
632   EXPECT_EQ("0b0",
633             WriteIntegerToString(static_cast</**/ ::std::int8_t>(0), 2, true));
634   EXPECT_EQ("0b1100100", WriteIntegerToString(
635                              static_cast</**/ ::std::int8_t>(100), 2, true));
636   EXPECT_EQ("0b1111111", WriteIntegerToString(
637                              static_cast</**/ ::std::int8_t>(127), 2, true));
638 
639   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::uint16_t>(0), 2,
640                                         false));
641   EXPECT_EQ(
642       "0b1111101000",
643       WriteIntegerToString(static_cast</**/ ::std::uint16_t>(1000), 2, false));
644   EXPECT_EQ(
645       "0b1111111111111111",
646       WriteIntegerToString(static_cast</**/ ::std::uint16_t>(65535), 2, false));
647   EXPECT_EQ(
648       "-0b1000000000000000",
649       WriteIntegerToString(static_cast</**/ ::std::int16_t>(-32768), 2, false));
650   EXPECT_EQ(
651       "-0b10011100010000",
652       WriteIntegerToString(static_cast</**/ ::std::int16_t>(-10000), 2, false));
653   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::int16_t>(0), 2,
654                                         false));
655   EXPECT_EQ(
656       "0b111111111111111",
657       WriteIntegerToString(static_cast</**/ ::std::int16_t>(32767), 2, false));
658 
659   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::uint16_t>(0), 2,
660                                         true));
661   EXPECT_EQ(
662       "0b11_11101000",
663       WriteIntegerToString(static_cast</**/ ::std::uint16_t>(1000), 2, true));
664   EXPECT_EQ(
665       "0b11111111_11111111",
666       WriteIntegerToString(static_cast</**/ ::std::uint16_t>(65535), 2, true));
667   EXPECT_EQ(
668       "-0b10000000_00000000",
669       WriteIntegerToString(static_cast</**/ ::std::int16_t>(-32768), 2, true));
670   EXPECT_EQ(
671       "-0b11_11101000",
672       WriteIntegerToString(static_cast</**/ ::std::int16_t>(-1000), 2, true));
673   EXPECT_EQ(
674       "-0b11_11100111",
675       WriteIntegerToString(static_cast</**/ ::std::int16_t>(-999), 2, true));
676   EXPECT_EQ("0b0",
677             WriteIntegerToString(static_cast</**/ ::std::int16_t>(0), 2, true));
678   EXPECT_EQ(
679       "0b1111111_11111111",
680       WriteIntegerToString(static_cast</**/ ::std::int16_t>(32767), 2, true));
681 
682   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::uint32_t>(0), 2,
683                                         false));
684   EXPECT_EQ("0b11110100001001000000",
685             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(1000000), 2,
686                                  false));
687   EXPECT_EQ("0b11111111111111111111111111111111",
688             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(4294967295),
689                                  2, false));
690   EXPECT_EQ("-0b10000000000000000000000000000000",
691             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-2147483648),
692                                  2, false));
693   EXPECT_EQ("-0b11000011010100000",
694             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-100000), 2,
695                                  false));
696   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::int32_t>(0), 2,
697                                         false));
698   EXPECT_EQ("0b1111111111111111111111111111111",
699             WriteIntegerToString(static_cast</**/ ::std::int32_t>(2147483647),
700                                  2, false));
701 
702   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::uint32_t>(0), 2,
703                                         true));
704   EXPECT_EQ("0b1111_01000010_01000000",
705             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(1000000), 2,
706                                  true));
707   EXPECT_EQ("0b11111111_11111111_11111111_11111111",
708             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(4294967295U),
709                                  2, true));
710   EXPECT_EQ("-0b10000000_00000000_00000000_00000000",
711             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-2147483648L),
712                                  2, true));
713   EXPECT_EQ("-0b1111_01000010_01000000",
714             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-1000000), 2,
715                                  true));
716   EXPECT_EQ("0b0",
717             WriteIntegerToString(static_cast</**/ ::std::int32_t>(0), 2, true));
718   EXPECT_EQ("0b1111111_11111111_11111111_11111111",
719             WriteIntegerToString(static_cast</**/ ::std::int32_t>(2147483647),
720                                  2, true));
721 
722   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::uint64_t>(0), 2,
723                                         false));
724   EXPECT_EQ("0b11110100001001000000",
725             WriteIntegerToString(static_cast</**/ ::std::uint64_t>(1000000), 2,
726                                  false));
727   EXPECT_EQ(
728       "0b1111111111111111111111111111111111111111111111111111111111111111",
729       WriteIntegerToString(
730           static_cast</**/ ::std::uint64_t>(18446744073709551615UL), 2, false));
731   EXPECT_EQ(
732       "-0b1000000000000000000000000000000000000000000000000000000000000000",
733       WriteIntegerToString(
734           static_cast</**/ ::std::int64_t>(-9223372036854775807L - 1), 2,
735           false));
736   EXPECT_EQ("-0b11000011010100000",
737             WriteIntegerToString(static_cast</**/ ::std::int64_t>(-100000), 2,
738                                  false));
739   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::int64_t>(0), 2,
740                                         false));
741   EXPECT_EQ(
742       "0b111111111111111111111111111111111111111111111111111111111111111",
743       WriteIntegerToString(
744           static_cast</**/ ::std::int64_t>(9223372036854775807L), 2, false));
745 
746   EXPECT_EQ("0b0", WriteIntegerToString(static_cast</**/ ::std::uint64_t>(0), 2,
747                                         true));
748   EXPECT_EQ("0b1111_01000010_01000000",
749             WriteIntegerToString(static_cast</**/ ::std::uint64_t>(1000000), 2,
750                                  true));
751   EXPECT_EQ(
752       "0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_"
753       "11111111",
754       WriteIntegerToString(
755           static_cast</**/ ::std::uint64_t>(18446744073709551615UL), 2, true));
756   EXPECT_EQ(
757       "-0b10000000_00000000_00000000_00000000_00000000_00000000_00000000_"
758       "00000000",
759       WriteIntegerToString(
760           static_cast</**/ ::std::int64_t>(-9223372036854775807L - 1), 2,
761           true));
762   EXPECT_EQ(
763       "-0b1_10000110_10100000",
764       WriteIntegerToString(static_cast</**/ ::std::int64_t>(-100000), 2, true));
765   EXPECT_EQ("0b0",
766             WriteIntegerToString(static_cast</**/ ::std::int64_t>(0), 2, true));
767   EXPECT_EQ(
768       "0b1111111_11111111_11111111_11111111_11111111_11111111_11111111_"
769       "11111111",
770       WriteIntegerToString(
771           static_cast</**/ ::std::int64_t>(9223372036854775807L), 2, true));
772 }
773 
TEST(WriteIntegerToTextStream,Hexadecimal)774 TEST(WriteIntegerToTextStream, Hexadecimal) {
775   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(0), 16,
776                                         false));
777   EXPECT_EQ("0x64", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(100),
778                                          16, false));
779   EXPECT_EQ("0xff", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(255),
780                                          16, false));
781   EXPECT_EQ("-0x80", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-128),
782                                           16, false));
783   EXPECT_EQ("-0x64", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-100),
784                                           16, false));
785   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::int8_t>(0), 16,
786                                         false));
787   EXPECT_EQ("0x64", WriteIntegerToString(static_cast</**/ ::std::int8_t>(100),
788                                          16, false));
789   EXPECT_EQ("0x7f", WriteIntegerToString(static_cast</**/ ::std::int8_t>(127),
790                                          16, false));
791 
792   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(0), 16,
793                                         true));
794   EXPECT_EQ("0x64", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(100),
795                                          16, true));
796   EXPECT_EQ("0xff", WriteIntegerToString(static_cast</**/ ::std::uint8_t>(255),
797                                          16, true));
798   EXPECT_EQ("-0x80", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-128),
799                                           16, true));
800   EXPECT_EQ("-0x64", WriteIntegerToString(static_cast</**/ ::std::int8_t>(-100),
801                                           16, true));
802   EXPECT_EQ("0x0",
803             WriteIntegerToString(static_cast</**/ ::std::int8_t>(0), 16, true));
804   EXPECT_EQ("0x64", WriteIntegerToString(static_cast</**/ ::std::int8_t>(100),
805                                          16, true));
806   EXPECT_EQ("0x7f", WriteIntegerToString(static_cast</**/ ::std::int8_t>(127),
807                                          16, true));
808 
809   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint16_t>(0),
810                                         16, false));
811   EXPECT_EQ("0x3e8", WriteIntegerToString(
812                          static_cast</**/ ::std::uint16_t>(1000), 16, false));
813   EXPECT_EQ("0xffff", WriteIntegerToString(
814                           static_cast</**/ ::std::uint16_t>(65535), 16, false));
815   EXPECT_EQ("-0x8000",
816             WriteIntegerToString(static_cast</**/ ::std::int16_t>(-32768), 16,
817                                  false));
818   EXPECT_EQ("-0x2710",
819             WriteIntegerToString(static_cast</**/ ::std::int16_t>(-10000), 16,
820                                  false));
821   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::int16_t>(0), 16,
822                                         false));
823   EXPECT_EQ("0x7fff", WriteIntegerToString(
824                           static_cast</**/ ::std::int16_t>(32767), 16, false));
825 
826   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint16_t>(0),
827                                         16, true));
828   EXPECT_EQ("0x3e8", WriteIntegerToString(
829                          static_cast</**/ ::std::uint16_t>(1000), 16, true));
830   EXPECT_EQ("0xffff", WriteIntegerToString(
831                           static_cast</**/ ::std::uint16_t>(65535), 16, true));
832   EXPECT_EQ("-0x8000", WriteIntegerToString(
833                            static_cast</**/ ::std::int16_t>(-32768), 16, true));
834   EXPECT_EQ("-0x3e8", WriteIntegerToString(
835                           static_cast</**/ ::std::int16_t>(-1000), 16, true));
836   EXPECT_EQ("-0x3e7", WriteIntegerToString(
837                           static_cast</**/ ::std::int16_t>(-999), 16, true));
838   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::int16_t>(0), 16,
839                                         true));
840   EXPECT_EQ("0x7fff", WriteIntegerToString(
841                           static_cast</**/ ::std::int16_t>(32767), 16, true));
842 
843   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint32_t>(0),
844                                         16, false));
845   EXPECT_EQ("0xf4240",
846             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(1000000), 16,
847                                  false));
848   EXPECT_EQ("0xffffffff",
849             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(4294967295),
850                                  16, false));
851   EXPECT_EQ("-0x80000000",
852             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-2147483648),
853                                  16, false));
854   EXPECT_EQ("-0x186a0",
855             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-100000), 16,
856                                  false));
857   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::int32_t>(0), 16,
858                                         false));
859   EXPECT_EQ("0x7fffffff",
860             WriteIntegerToString(static_cast</**/ ::std::int32_t>(2147483647),
861                                  16, false));
862 
863   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint32_t>(0),
864                                         16, true));
865   EXPECT_EQ("0xf_4240",
866             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(1000000), 16,
867                                  true));
868   EXPECT_EQ("0xffff_ffff",
869             WriteIntegerToString(static_cast</**/ ::std::uint32_t>(4294967295U),
870                                  16, true));
871   EXPECT_EQ("-0x8000_0000",
872             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-2147483648L),
873                                  16, true));
874   EXPECT_EQ("-0xf_4240",
875             WriteIntegerToString(static_cast</**/ ::std::int32_t>(-1000000), 16,
876                                  true));
877   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::int32_t>(0), 16,
878                                         true));
879   EXPECT_EQ("0x7fff_ffff",
880             WriteIntegerToString(static_cast</**/ ::std::int32_t>(2147483647),
881                                  16, true));
882 
883   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint64_t>(0),
884                                         16, false));
885   EXPECT_EQ("0xf4240",
886             WriteIntegerToString(static_cast</**/ ::std::uint64_t>(1000000), 16,
887                                  false));
888   EXPECT_EQ("0xffffffffffffffff",
889             WriteIntegerToString(
890                 static_cast</**/ ::std::uint64_t>(18446744073709551615UL), 16,
891                 false));
892   EXPECT_EQ("-0x8000000000000000",
893             WriteIntegerToString(
894                 static_cast</**/ ::std::int64_t>(-9223372036854775807L - 1), 16,
895                 false));
896   EXPECT_EQ("-0x186a0",
897             WriteIntegerToString(static_cast</**/ ::std::int64_t>(-100000), 16,
898                                  false));
899   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::int64_t>(0), 16,
900                                         false));
901   EXPECT_EQ(
902       "0x7fffffffffffffff",
903       WriteIntegerToString(
904           static_cast</**/ ::std::int64_t>(9223372036854775807L), 16, false));
905 
906   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::uint64_t>(0),
907                                         16, true));
908   EXPECT_EQ("0xf_4240",
909             WriteIntegerToString(static_cast</**/ ::std::uint64_t>(1000000), 16,
910                                  true));
911   EXPECT_EQ(
912       "0xffff_ffff_ffff_ffff",
913       WriteIntegerToString(
914           static_cast</**/ ::std::uint64_t>(18446744073709551615UL), 16, true));
915   EXPECT_EQ("-0x8000_0000_0000_0000",
916             WriteIntegerToString(
917                 static_cast</**/ ::std::int64_t>(-9223372036854775807L - 1), 16,
918                 true));
919   EXPECT_EQ("-0x1_86a0",
920             WriteIntegerToString(static_cast</**/ ::std::int64_t>(-100000), 16,
921                                  true));
922   EXPECT_EQ("0x0", WriteIntegerToString(static_cast</**/ ::std::int64_t>(0), 16,
923                                         true));
924   EXPECT_EQ(
925       "0x7fff_ffff_ffff_ffff",
926       WriteIntegerToString(
927           static_cast</**/ ::std::int64_t>(9223372036854775807L), 16, true));
928 }
929 
930 // Small helper function for the various WriteFloatToTextStream tests; just sets
931 // up a stream, forwards its arguments to WriteFloatToTextStream, and then
932 // returns the text from the stream.
933 template <typename Arg0, typename... Args>
WriteFloatToString(Arg0 && arg0,Args &&...args)934 ::std::string WriteFloatToString(Arg0 &&arg0, Args &&... args) {
935   TextOutputStream stream;
936   WriteFloatToTextStream(::std::forward<Arg0>(arg0), &stream,
937                          ::std::forward<Args>(args)...);
938   return stream.Result();
939 }
940 
TEST(WriteFloatToTextStream,RegularNumbers)941 TEST(WriteFloatToTextStream, RegularNumbers) {
942   EXPECT_EQ("0", WriteFloatToString(0.0, TextOutputOptions()));
943   EXPECT_EQ("1", WriteFloatToString(1.0, TextOutputOptions()));
944   EXPECT_EQ("1.5", WriteFloatToString(1.5, TextOutputOptions()));
945   // TODO(bolms): Figure out how to get minimal-length output.
946   EXPECT_EQ("1.6000000000000001", WriteFloatToString(1.6, TextOutputOptions()));
947   EXPECT_EQ("123456789", WriteFloatToString(123456789.0, TextOutputOptions()));
948   EXPECT_EQ("12345678901234568",
949             WriteFloatToString(12345678901234567.0, TextOutputOptions()));
950   EXPECT_EQ("-12345678901234568",
951             WriteFloatToString(-12345678901234567.0, TextOutputOptions()));
952   EXPECT_EQ("-1.2345678901234568e+17",
953             WriteFloatToString(-123456789012345678.0, TextOutputOptions()));
954   EXPECT_EQ("4.9406564584124654e-324",
955             WriteFloatToString(::std::numeric_limits<double>::denorm_min(),
956                                TextOutputOptions()));
957   EXPECT_EQ("1.7976931348623157e+308",
958             WriteFloatToString(::std::numeric_limits<double>::max(),
959                                TextOutputOptions()));
960 
961   EXPECT_EQ("0", WriteFloatToString(0.0f, TextOutputOptions()));
962   EXPECT_EQ("1", WriteFloatToString(1.0f, TextOutputOptions()));
963   EXPECT_EQ("1.5", WriteFloatToString(1.5f, TextOutputOptions()));
964   EXPECT_EQ("1.60000002", WriteFloatToString(1.6f, TextOutputOptions()));
965   EXPECT_EQ("123456792", WriteFloatToString(123456789.0f, TextOutputOptions()));
966   EXPECT_EQ("1.23456784e+16",
967             WriteFloatToString(12345678901234567.0f, TextOutputOptions()));
968   EXPECT_EQ("-1.23456784e+16",
969             WriteFloatToString(-12345678901234567.0f, TextOutputOptions()));
970   EXPECT_EQ("-1.00000003e+16",
971             WriteFloatToString(-10000000000000000.0f, TextOutputOptions()));
972   EXPECT_EQ("1.40129846e-45",
973             WriteFloatToString(::std::numeric_limits<float>::denorm_min(),
974                                TextOutputOptions()));
975   EXPECT_EQ("3.40282347e+38",
976             WriteFloatToString(::std::numeric_limits<float>::max(),
977                                TextOutputOptions()));
978 }
979 
TEST(WriteFloatToTextStream,Infinities)980 TEST(WriteFloatToTextStream, Infinities) {
981   EXPECT_EQ("Inf", WriteFloatToString(2 * ::std::numeric_limits<double>::max(),
982                                       TextOutputOptions()));
983   EXPECT_EQ("Inf", WriteFloatToString(2 * ::std::numeric_limits<float>::max(),
984                                       TextOutputOptions()));
985   EXPECT_EQ("-Inf",
986             WriteFloatToString(-2 * ::std::numeric_limits<double>::max(),
987                                TextOutputOptions()));
988   EXPECT_EQ("-Inf", WriteFloatToString(-2 * ::std::numeric_limits<float>::max(),
989                                        TextOutputOptions()));
990 }
991 
992 // C++ does not provide great low-level manipulation for NaNs, so we resort to
993 // this mess.
MakeNanDouble(::std::uint64_t payload,int sign)994 double MakeNanDouble(::std::uint64_t payload, int sign) {
995   payload |= 0x7ff0000000000000UL;
996   if (sign < 0) {
997     payload |= 0x8000000000000000UL;
998   }
999   double result;
1000   ::std::memcpy(&result, &payload, sizeof result);
1001   return result;
1002 }
1003 
MakeNanFloat(::std::uint32_t payload,int sign)1004 float MakeNanFloat(::std::uint32_t payload, int sign) {
1005   payload |= 0x7f800000U;
1006   if (sign < 0) {
1007     payload |= 0x80000000U;
1008   }
1009   float result;
1010   ::std::memcpy(&result, &payload, sizeof result);
1011   return result;
1012 }
1013 
TEST(WriteFloatToTextStream,Nans)1014 TEST(WriteFloatToTextStream, Nans) {
1015   EXPECT_EQ("NaN(0x1)",
1016             WriteFloatToString(MakeNanDouble(1, 0), TextOutputOptions()));
1017   EXPECT_EQ("NaN(0x1)",
1018             WriteFloatToString(MakeNanFloat(1, 0), TextOutputOptions()));
1019   EXPECT_EQ("NaN(0x10000)",
1020             WriteFloatToString(MakeNanDouble(0x10000, 0), TextOutputOptions()));
1021   EXPECT_EQ("NaN(0x7fffff)", WriteFloatToString(MakeNanFloat(0x7fffffU, 0),
1022                                                 TextOutputOptions()));
1023   EXPECT_EQ("NaN(0xfffffffffffff)",
1024             WriteFloatToString(MakeNanDouble(0xfffffffffffffUL, 0),
1025                                TextOutputOptions()));
1026   EXPECT_EQ("-NaN(0x7fffff)", WriteFloatToString(MakeNanFloat(0x7fffffU, -1),
1027                                                  TextOutputOptions()));
1028   EXPECT_EQ("-NaN(0xfffffffffffff)",
1029             WriteFloatToString(MakeNanDouble(0xfffffffffffffUL, -1),
1030                                TextOutputOptions()));
1031   EXPECT_EQ("NaN(0x10000)",
1032             WriteFloatToString(MakeNanFloat(0x10000, 0), TextOutputOptions()));
1033   EXPECT_EQ("-NaN(0x1)",
1034             WriteFloatToString(MakeNanDouble(1, -1), TextOutputOptions()));
1035   EXPECT_EQ("-NaN(0x1)",
1036             WriteFloatToString(MakeNanFloat(1, -1), TextOutputOptions()));
1037   EXPECT_EQ("-NaN(0x10000)", WriteFloatToString(MakeNanDouble(0x10000, -1),
1038                                                 TextOutputOptions()));
1039   EXPECT_EQ("-NaN(0x10000)",
1040             WriteFloatToString(MakeNanFloat(0x10000, -1), TextOutputOptions()));
1041   EXPECT_EQ("-NaN(0x1_0000)",
1042             WriteFloatToString(MakeNanDouble(0x10000, -1),
1043                                TextOutputOptions().WithDigitGrouping(true)));
1044   EXPECT_EQ("-NaN(0x1_0000)",
1045             WriteFloatToString(MakeNanFloat(0x10000, -1),
1046                                TextOutputOptions().WithDigitGrouping(true)));
1047 }
1048 
TEST(DecodeFloat,RegularNumbers)1049 TEST(DecodeFloat, RegularNumbers) {
1050   double double_result;
1051   EXPECT_TRUE(DecodeFloat("0", &double_result));
1052   EXPECT_EQ(0.0, double_result);
1053   EXPECT_FALSE(::std::signbit(double_result));
1054   EXPECT_TRUE(DecodeFloat("-0", &double_result));
1055   EXPECT_EQ(0.0, double_result);
1056   EXPECT_TRUE(::std::signbit(double_result));
1057   EXPECT_TRUE(DecodeFloat("0.0", &double_result));
1058   EXPECT_EQ(0.0, double_result);
1059   EXPECT_TRUE(DecodeFloat("0.0e100", &double_result));
1060   EXPECT_EQ(0.0, double_result);
1061   EXPECT_TRUE(DecodeFloat("0x0.0p100", &double_result));
1062   EXPECT_EQ(0.0, double_result);
1063   EXPECT_TRUE(DecodeFloat("1", &double_result));
1064   EXPECT_EQ(1.0, double_result);
1065   EXPECT_TRUE(DecodeFloat("1.5", &double_result));
1066   EXPECT_EQ(1.5, double_result);
1067   EXPECT_TRUE(DecodeFloat("1.6", &double_result));
1068   EXPECT_EQ(1.6, double_result);
1069   EXPECT_TRUE(DecodeFloat("1.6000000000000001", &double_result));
1070   EXPECT_EQ(1.6, double_result);
1071   EXPECT_TRUE(DecodeFloat("123456789", &double_result));
1072   EXPECT_EQ(123456789.0, double_result);
1073   EXPECT_TRUE(DecodeFloat("-1.234567890123458e+17", &double_result));
1074   EXPECT_EQ(-1.234567890123458e+17, double_result);
1075   EXPECT_TRUE(DecodeFloat("4.9406564584124654e-324", &double_result));
1076   EXPECT_EQ(4.9406564584124654e-324, double_result);
1077   EXPECT_TRUE(DecodeFloat("1.7976931348623157e+308", &double_result));
1078   EXPECT_EQ(1.7976931348623157e+308, double_result);
1079   EXPECT_TRUE(DecodeFloat(
1080       "000000000000000000000000000004.9406564584124654e-324", &double_result));
1081   EXPECT_EQ(4.9406564584124654e-324, double_result);
1082 
1083   float float_result;
1084   EXPECT_TRUE(DecodeFloat("0", &float_result));
1085   EXPECT_EQ(0.0f, float_result);
1086   EXPECT_FALSE(::std::signbit(float_result));
1087   EXPECT_TRUE(DecodeFloat("-0", &float_result));
1088   EXPECT_EQ(0.0f, float_result);
1089   EXPECT_TRUE(::std::signbit(float_result));
1090   EXPECT_TRUE(DecodeFloat("0.0", &float_result));
1091   EXPECT_EQ(0.0f, float_result);
1092   EXPECT_TRUE(DecodeFloat("0.0e100", &float_result));
1093   EXPECT_EQ(0.0f, float_result);
1094   EXPECT_TRUE(DecodeFloat("0x0.0p100", &float_result));
1095   EXPECT_EQ(0.0f, float_result);
1096   EXPECT_TRUE(DecodeFloat("1", &float_result));
1097   EXPECT_EQ(1.0f, float_result);
1098   EXPECT_TRUE(DecodeFloat("1.5", &float_result));
1099   EXPECT_EQ(1.5f, float_result);
1100   EXPECT_TRUE(DecodeFloat("1.6", &float_result));
1101   EXPECT_EQ(1.6f, float_result);
1102   EXPECT_TRUE(DecodeFloat("1.6000000000000001", &float_result));
1103   EXPECT_EQ(1.6f, float_result);
1104   EXPECT_TRUE(DecodeFloat("123456789", &float_result));
1105   EXPECT_EQ(123456789.0f, float_result);
1106   EXPECT_TRUE(DecodeFloat("-1.23456784e+16", &float_result));
1107   EXPECT_EQ(-1.23456784e+16f, float_result);
1108   EXPECT_TRUE(DecodeFloat("1.40129846e-45", &float_result));
1109   EXPECT_EQ(1.40129846e-45f, float_result);
1110   EXPECT_TRUE(DecodeFloat("3.40282347e+38", &float_result));
1111   EXPECT_EQ(3.40282347e+38f, float_result);
1112 
1113   // TODO(bolms): "_"-grouped numbers, like "123_456.789", should probably be
1114   // allowed.
1115 }
1116 
TEST(DecodeFloat,BadValues)1117 TEST(DecodeFloat, BadValues) {
1118   double result;
1119   float float_result;
1120 
1121   // No text is not a value.
1122   EXPECT_FALSE(DecodeFloat("", &result));
1123 
1124   // Trailing characters after "Inf" are not allowed.
1125   EXPECT_FALSE(DecodeFloat("INF+", &result));
1126   EXPECT_FALSE(DecodeFloat("Infinity", &result));
1127 
1128   // Trailing characters after "NaN" are not allowed.
1129   EXPECT_FALSE(DecodeFloat("NaN(", &result));
1130   EXPECT_FALSE(DecodeFloat("NaN(0]", &result));
1131   EXPECT_FALSE(DecodeFloat("NaNaNaNa", &result));
1132 
1133   // Non-number NaN payloads are not allowed.
1134   EXPECT_FALSE(DecodeFloat("NaN()", &result));
1135   EXPECT_FALSE(DecodeFloat("NaN(x)", &result));
1136   EXPECT_FALSE(DecodeFloat("NaN(0x)", &result));
1137 
1138   // Negative NaN payloads are not allowed.
1139   EXPECT_FALSE(DecodeFloat("NaN(-1)", &result));
1140   EXPECT_FALSE(DecodeFloat("NaN(-0)", &result));
1141 
1142   // NaN with zero payload is infinity, and is thus not allowed.
1143   EXPECT_FALSE(DecodeFloat("NaN(0)", &result));
1144   EXPECT_FALSE(DecodeFloat("-NaN(0)", &result));
1145 
1146   // NaN double payloads must be no more than 52 bits.
1147   EXPECT_FALSE(DecodeFloat("NaN(0x10_0000_0000_0000)", &result));
1148   EXPECT_FALSE(DecodeFloat("NaN(0x8000_0000_0000_0000)", &result));
1149   EXPECT_FALSE(DecodeFloat("NaN(0x1_0000_0000_0000_0000)", &result));
1150 
1151   // NaN float payloads must be no more than 23 bits.
1152   EXPECT_FALSE(DecodeFloat("NaN(0x80_0000)", &float_result));
1153   EXPECT_FALSE(DecodeFloat("NaN(0x8000_0000)", &float_result));
1154   EXPECT_FALSE(DecodeFloat("NaN(0x1_0000_0000)", &float_result));
1155 
1156   // Trailing characters after regular values are not allowed.
1157   EXPECT_FALSE(DecodeFloat("0x", &result));
1158   EXPECT_FALSE(DecodeFloat("0e0a", &result));
1159   EXPECT_FALSE(DecodeFloat("0b0", &result));
1160   EXPECT_FALSE(DecodeFloat("0a", &result));
1161   EXPECT_FALSE(DecodeFloat("1..", &result));
1162 
1163   // Grouping characters like "," should not be allowed.
1164   EXPECT_FALSE(DecodeFloat("123,456", &result));
1165   EXPECT_FALSE(DecodeFloat("123'456", &result));
1166 }
1167 
TEST(DecodeFloat,Infinities)1168 TEST(DecodeFloat, Infinities) {
1169   double double_result;
1170   EXPECT_TRUE(DecodeFloat("Inf", &double_result));
1171   EXPECT_TRUE(::std::isinf(double_result));
1172   EXPECT_FALSE(::std::signbit(double_result));
1173   EXPECT_TRUE(DecodeFloat("-Inf", &double_result));
1174   EXPECT_TRUE(::std::isinf(double_result));
1175   EXPECT_TRUE(::std::signbit(double_result));
1176   EXPECT_TRUE(DecodeFloat("+Inf", &double_result));
1177   EXPECT_TRUE(::std::isinf(double_result));
1178   EXPECT_FALSE(::std::signbit(double_result));
1179   EXPECT_TRUE(DecodeFloat("iNF", &double_result));
1180   EXPECT_TRUE(::std::isinf(double_result));
1181   EXPECT_FALSE(::std::signbit(double_result));
1182   EXPECT_TRUE(DecodeFloat("-iNF", &double_result));
1183   EXPECT_TRUE(::std::isinf(double_result));
1184   EXPECT_TRUE(::std::signbit(double_result));
1185   EXPECT_TRUE(DecodeFloat("+iNF", &double_result));
1186   EXPECT_TRUE(::std::isinf(double_result));
1187   EXPECT_FALSE(::std::signbit(double_result));
1188 }
1189 
1190 // Helper functions for converting NaNs to bit patterns, so that the exact bit
1191 // pattern result can be tested.
DoubleBitPattern(double n)1192 ::std::uint64_t DoubleBitPattern(double n) {
1193   ::std::uint64_t result;
1194   memcpy(&result, &n, sizeof(result));
1195   return result;
1196 }
1197 
FloatBitPattern(float n)1198 ::std::uint32_t FloatBitPattern(float n) {
1199   ::std::uint32_t result;
1200   memcpy(&result, &n, sizeof(result));
1201   return result;
1202 }
1203 
TEST(DecodeFloat,Nans)1204 TEST(DecodeFloat, Nans) {
1205   double double_result;
1206   EXPECT_TRUE(DecodeFloat("nan", &double_result));
1207   EXPECT_TRUE(::std::isnan(double_result));
1208   EXPECT_FALSE(::std::signbit(double_result));
1209   EXPECT_TRUE(DecodeFloat("-NAN", &double_result));
1210   EXPECT_TRUE(::std::isnan(double_result));
1211   EXPECT_TRUE(::std::signbit(double_result));
1212   EXPECT_TRUE(DecodeFloat("NaN(1)", &double_result));
1213   EXPECT_TRUE(::std::isnan(double_result));
1214   EXPECT_EQ(0x7ff0000000000001UL, DoubleBitPattern(double_result));
1215   EXPECT_TRUE(DecodeFloat("nAn(0x1000)", &double_result));
1216   EXPECT_TRUE(::std::isnan(double_result));
1217   EXPECT_EQ(0x7ff0000000001000UL, DoubleBitPattern(double_result));
1218   EXPECT_TRUE(DecodeFloat("NaN(0b11000011)", &double_result));
1219   EXPECT_TRUE(::std::isnan(double_result));
1220   EXPECT_EQ(0x7ff00000000000c3UL, DoubleBitPattern(double_result));
1221   EXPECT_TRUE(DecodeFloat("-NaN(0b11000011)", &double_result));
1222   EXPECT_TRUE(::std::isnan(double_result));
1223   EXPECT_EQ(0xfff00000000000c3UL, DoubleBitPattern(double_result));
1224   EXPECT_TRUE(DecodeFloat("+NaN(0b11000011)", &double_result));
1225   EXPECT_TRUE(::std::isnan(double_result));
1226   EXPECT_EQ(0x7ff00000000000c3UL, DoubleBitPattern(double_result));
1227   EXPECT_TRUE(DecodeFloat("NaN(0xf_ffff_ffff_ffff)", &double_result));
1228   EXPECT_TRUE(::std::isnan(double_result));
1229   EXPECT_EQ(0x7fffffffffffffffUL, DoubleBitPattern(double_result));
1230   EXPECT_TRUE(DecodeFloat("-NaN(0xf_ffff_ffff_ffff)", &double_result));
1231   EXPECT_TRUE(::std::isnan(double_result));
1232   EXPECT_EQ(0xffffffffffffffffUL, DoubleBitPattern(double_result));
1233 
1234   float float_result;
1235   EXPECT_TRUE(DecodeFloat("nan", &float_result));
1236   EXPECT_TRUE(::std::isnan(float_result));
1237   EXPECT_FALSE(::std::signbit(float_result));
1238   EXPECT_TRUE(DecodeFloat("-NAN", &float_result));
1239   EXPECT_TRUE(::std::isnan(float_result));
1240   EXPECT_TRUE(::std::signbit(float_result));
1241   EXPECT_TRUE(DecodeFloat("NaN(1)", &float_result));
1242   EXPECT_TRUE(::std::isnan(float_result));
1243   EXPECT_EQ(0x7f800001U, FloatBitPattern(float_result));
1244   EXPECT_TRUE(DecodeFloat("nAn(0x1000)", &float_result));
1245   EXPECT_TRUE(::std::isnan(float_result));
1246   EXPECT_EQ(0x7f801000U, FloatBitPattern(float_result));
1247   EXPECT_TRUE(DecodeFloat("NaN(0b11000011)", &float_result));
1248   EXPECT_TRUE(::std::isnan(float_result));
1249   EXPECT_EQ(0x7f8000c3U, FloatBitPattern(float_result));
1250   EXPECT_TRUE(DecodeFloat("-NaN(0b11000011)", &float_result));
1251   EXPECT_TRUE(::std::isnan(float_result));
1252   EXPECT_EQ(0xff8000c3U, FloatBitPattern(float_result));
1253   EXPECT_TRUE(DecodeFloat("+NaN(0b11000011)", &float_result));
1254   EXPECT_TRUE(::std::isnan(float_result));
1255   EXPECT_EQ(0x7f8000c3U, FloatBitPattern(float_result));
1256   EXPECT_TRUE(DecodeFloat("NaN(0x7f_ffff)", &float_result));
1257   EXPECT_TRUE(::std::isnan(float_result));
1258   EXPECT_EQ(0x7fffffffU, FloatBitPattern(float_result));
1259   EXPECT_TRUE(DecodeFloat("-NaN(0x7f_ffff)", &float_result));
1260   EXPECT_TRUE(::std::isnan(float_result));
1261   EXPECT_EQ(0xffffffffU, FloatBitPattern(float_result));
1262 }
1263 
1264 }  // namespace test
1265 }  // namespace support
1266 }  // namespace emboss
1267