xref: /llvm-project/libc/test/src/stdio/sprintf_test.cpp (revision 9c868195daf153920272269d2af1c4b62670c4b9) 
1 //===-- Unittests for sprintf ---------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "src/__support/macros/config.h"
10 #include "src/stdio/sprintf.h"
11 
12 #include "src/__support/FPUtil/FPBits.h"
13 #include "src/errno/libc_errno.h"
14 #include "test/UnitTest/RoundingModeUtils.h"
15 #include "test/UnitTest/Test.h"
16 #include <inttypes.h>
17 
18 // TODO: Add a comment here explaining the printf format string.
19 
20 // #include <stdio.h>
21 // namespace LIBC_NAMESPACE_DECL {
22 // using ::sprintf;
23 // }
24 
25 using LIBC_NAMESPACE::fputil::testing::ForceRoundingMode;
26 using LIBC_NAMESPACE::fputil::testing::RoundingMode;
27 
28 // Subtract 1 from sizeof(expected_str) to account for the null byte.
29 #define ASSERT_STREQ_LEN(actual_written, actual_str, expected_str)             \
30   EXPECT_EQ(actual_written, static_cast<int>(sizeof(expected_str) - 1));       \
31   EXPECT_STREQ(actual_str, expected_str);
32 
33 #define macro_test(FMT, X, expected)                                           \
34   do {                                                                         \
35     for (char &c : buff) {                                                     \
36       c = 0;                                                                   \
37     }                                                                          \
38     written = LIBC_NAMESPACE::sprintf(buff, "%" FMT, X);                       \
39     ASSERT_STREQ_LEN(written, buff, expected);                                 \
40   } while (0)
41 
42 TEST(LlvmLibcSPrintfTest, Macros) {
43   char buff[128];
44   int written;
45   macro_test(PRIu8, 1, "1");
46   macro_test(PRIX16, 0xAA, "AA");
47   macro_test(PRId32, -123, "-123");
48   macro_test(PRIX32, 0xFFFFFF85, "FFFFFF85");
49   macro_test(PRIo8, 0xFF, "377");
50   macro_test(PRIo64, 0123456712345671234567ll, "123456712345671234567");
51 }
52 
53 TEST(LlvmLibcSPrintfTest, SimpleNoConv) {
54   char buff[64];
55   int written;
56 
57   written =
58       LIBC_NAMESPACE::sprintf(buff, "A simple string with no conversions.");
59   ASSERT_STREQ_LEN(written, buff, "A simple string with no conversions.");
60 }
61 
62 TEST(LlvmLibcSPrintfTest, PercentConv) {
63   char buff[64];
64   int written;
65 
66   written = LIBC_NAMESPACE::sprintf(buff, "%%");
67   ASSERT_STREQ_LEN(written, buff, "%");
68 
69   written = LIBC_NAMESPACE::sprintf(buff, "abc %% def");
70   ASSERT_STREQ_LEN(written, buff, "abc % def");
71 
72   written = LIBC_NAMESPACE::sprintf(buff, "%%%%%%");
73   ASSERT_STREQ_LEN(written, buff, "%%%");
74 }
75 
76 TEST(LlvmLibcSPrintfTest, CharConv) {
77   char buff[64];
78   int written;
79 
80   written = LIBC_NAMESPACE::sprintf(buff, "%c", 'a');
81   ASSERT_STREQ_LEN(written, buff, "a");
82 
83   written = LIBC_NAMESPACE::sprintf(buff, "%3c %-3c", '1', '2');
84   ASSERT_STREQ_LEN(written, buff, "  1 2  ");
85 
86   written = LIBC_NAMESPACE::sprintf(buff, "%*c", 2, '3');
87   ASSERT_STREQ_LEN(written, buff, " 3");
88 }
89 
90 TEST(LlvmLibcSPrintfTest, StringConv) {
91   char buff[64];
92   int written;
93 
94   written = LIBC_NAMESPACE::sprintf(buff, "%s", "abcDEF123");
95   ASSERT_STREQ_LEN(written, buff, "abcDEF123");
96 
97   written = LIBC_NAMESPACE::sprintf(buff, "%10s %-10s", "centered", "title");
98   ASSERT_STREQ_LEN(written, buff, "  centered title     ");
99 
100   written = LIBC_NAMESPACE::sprintf(buff, "%-5.4s%-4.4s", "words can describe",
101                                     "soups most delicious");
102   ASSERT_STREQ_LEN(written, buff, "word soup");
103 
104   written = LIBC_NAMESPACE::sprintf(buff, "%*s %.*s %*.*s", 10, "beginning", 2,
105                                     "isn't", 12, 10, "important. Ever.");
106   ASSERT_STREQ_LEN(written, buff, " beginning is   important.");
107 
108 #ifndef LIBC_COPT_PRINTF_NO_NULLPTR_CHECKS
109   written = LIBC_NAMESPACE::sprintf(buff, "%s", nullptr);
110   ASSERT_STREQ_LEN(written, buff, "(null)");
111 #endif // LIBC_COPT_PRINTF_NO_NULLPTR_CHECKS
112 }
113 
114 TEST(LlvmLibcSPrintfTest, IntConv) {
115   char buff[64];
116   int written;
117 
118   // Basic Tests.
119 
120   written = LIBC_NAMESPACE::sprintf(buff, "%d", 123);
121   ASSERT_STREQ_LEN(written, buff, "123");
122 
123   written = LIBC_NAMESPACE::sprintf(buff, "%i", -456);
124   ASSERT_STREQ_LEN(written, buff, "-456");
125 
126   // Length Modifier Tests.
127 
128   written = LIBC_NAMESPACE::sprintf(buff, "%hhu", 257); // 0x101
129   ASSERT_STREQ_LEN(written, buff, "1");
130 
131   written = LIBC_NAMESPACE::sprintf(buff, "%llu", 18446744073709551615ull);
132   ASSERT_STREQ_LEN(written, buff, "18446744073709551615"); // ull max
133 
134   written = LIBC_NAMESPACE::sprintf(buff, "%u", ~0);
135   if (sizeof(int) == 4) {
136     ASSERT_STREQ_LEN(written, buff, "4294967295");
137   }
138 
139   written = LIBC_NAMESPACE::sprintf(buff, "%tu", ~ptrdiff_t(0));
140   if (sizeof(ptrdiff_t) == 8) {
141     ASSERT_STREQ_LEN(written, buff, "18446744073709551615");
142   } else if (sizeof(ptrdiff_t) == 4) {
143     ASSERT_STREQ_LEN(written, buff, "4294967295");
144   }
145 
146   written = LIBC_NAMESPACE::sprintf(buff, "%lld", -9223372036854775807ll - 1ll);
147   ASSERT_STREQ_LEN(written, buff, "-9223372036854775808"); // ll min
148 
149   written = LIBC_NAMESPACE::sprintf(buff, "%w3d", 5807);
150   ASSERT_STREQ_LEN(written, buff, "7");
151 
152   written = LIBC_NAMESPACE::sprintf(buff, "%w3d", 1);
153   ASSERT_STREQ_LEN(written, buff, "1");
154 
155   written = LIBC_NAMESPACE::sprintf(buff, "%w64d", 9223372036854775807ll);
156   ASSERT_STREQ_LEN(written, buff, "9223372036854775807");
157 
158   written = LIBC_NAMESPACE::sprintf(buff, "%w-1d", 5807);
159   ASSERT_STREQ_LEN(written, buff, "%w-1d");
160 
161   written = LIBC_NAMESPACE::sprintf(buff, "%w0d", 5807);
162   ASSERT_STREQ_LEN(written, buff, "%w0d");
163 
164   written = LIBC_NAMESPACE::sprintf(buff, "%w999d", 9223372036854775807ll);
165   ASSERT_STREQ_LEN(written, buff, "9223372036854775807");
166 
167   written = LIBC_NAMESPACE::sprintf(buff, "%winvalid%w1d", 5807, 5807);
168   ASSERT_STREQ_LEN(written, buff, "%winvalid1");
169 
170   written = LIBC_NAMESPACE::sprintf(buff, "%w-1d%w1d", 5807, 5807);
171   ASSERT_STREQ_LEN(written, buff, "%w-1d1");
172 
173   char format[64];
174   char uintmax[128];
175   LIBC_NAMESPACE::sprintf(format, "%%w%du", sizeof(uintmax_t) * CHAR_BIT);
176   const int uintmax_len =
177       LIBC_NAMESPACE::sprintf(uintmax, "%ju", sizeof(uintmax_t) * CHAR_BIT);
178   written = LIBC_NAMESPACE::sprintf(buff, format, sizeof(uintmax_t) * CHAR_BIT);
179   EXPECT_EQ(written, uintmax_len);
180   ASSERT_STREQ(buff, uintmax);
181 
182   written = LIBC_NAMESPACE::sprintf(buff, "%w64u", 18446744073709551615ull);
183   ASSERT_STREQ_LEN(written, buff, "18446744073709551615"); // ull max
184 
185   written =
186       LIBC_NAMESPACE::sprintf(buff, "%w64d", -9223372036854775807ll - 1ll);
187   ASSERT_STREQ_LEN(written, buff, "-9223372036854775808"); // ll min
188 
189   written = LIBC_NAMESPACE::sprintf(buff, "%wf3d", 5807);
190   ASSERT_STREQ_LEN(written, buff, "7");
191 
192   written = LIBC_NAMESPACE::sprintf(buff, "%wf3d", 1);
193   ASSERT_STREQ_LEN(written, buff, "1");
194 
195   written = LIBC_NAMESPACE::sprintf(buff, "%wf64u", 18446744073709551615ull);
196   ASSERT_STREQ_LEN(written, buff, "18446744073709551615"); // ull max
197 
198   written =
199       LIBC_NAMESPACE::sprintf(buff, "%wf64d", -9223372036854775807ll - 1ll);
200   ASSERT_STREQ_LEN(written, buff, "-9223372036854775808"); // ll min
201 
202   written = LIBC_NAMESPACE::sprintf(buff, "%wf0d", 5807);
203   ASSERT_STREQ_LEN(written, buff, "%wf0d");
204 
205   written = LIBC_NAMESPACE::sprintf(buff, "%wf-1d", 5807);
206   ASSERT_STREQ_LEN(written, buff, "%wf-1d");
207 
208   written = LIBC_NAMESPACE::sprintf(buff, "%wfinvalid%wf1d", 5807, 5807);
209   ASSERT_STREQ_LEN(written, buff, "%wfinvalid1");
210 
211   written = LIBC_NAMESPACE::sprintf(buff, "%wf-1d%wf1d", 5807, 5807);
212   ASSERT_STREQ_LEN(written, buff, "%wf-1d1");
213 
214   written = LIBC_NAMESPACE::sprintf(buff, "%wf999d", 9223372036854775807ll);
215   ASSERT_STREQ_LEN(written, buff, "9223372036854775807");
216 
217   // Min Width Tests.
218 
219   written = LIBC_NAMESPACE::sprintf(buff, "%4d", 789);
220   ASSERT_STREQ_LEN(written, buff, " 789");
221 
222   written = LIBC_NAMESPACE::sprintf(buff, "%2d", 987);
223   ASSERT_STREQ_LEN(written, buff, "987");
224 
225   // Precision Tests.
226 
227   written = LIBC_NAMESPACE::sprintf(buff, "%d", 0);
228   ASSERT_STREQ_LEN(written, buff, "0");
229 
230   written = LIBC_NAMESPACE::sprintf(buff, "%.0d", 0);
231   ASSERT_STREQ_LEN(written, buff, "");
232 
233   written = LIBC_NAMESPACE::sprintf(buff, "%.5d", 654);
234   ASSERT_STREQ_LEN(written, buff, "00654");
235 
236   written = LIBC_NAMESPACE::sprintf(buff, "%.5d", -321);
237   ASSERT_STREQ_LEN(written, buff, "-00321");
238 
239   written = LIBC_NAMESPACE::sprintf(buff, "%.2d", 135);
240   ASSERT_STREQ_LEN(written, buff, "135");
241 
242   // Flag Tests.
243 
244   written = LIBC_NAMESPACE::sprintf(buff, "%.5d", -321);
245   ASSERT_STREQ_LEN(written, buff, "-00321");
246 
247   written = LIBC_NAMESPACE::sprintf(buff, "%-5d", 246);
248   ASSERT_STREQ_LEN(written, buff, "246  ");
249 
250   written = LIBC_NAMESPACE::sprintf(buff, "%-5d", -147);
251   ASSERT_STREQ_LEN(written, buff, "-147 ");
252 
253   written = LIBC_NAMESPACE::sprintf(buff, "%+d", 258);
254   ASSERT_STREQ_LEN(written, buff, "+258");
255 
256   written = LIBC_NAMESPACE::sprintf(buff, "% d", 369);
257   ASSERT_STREQ_LEN(written, buff, " 369");
258 
259   written = LIBC_NAMESPACE::sprintf(buff, "%05d", 470);
260   ASSERT_STREQ_LEN(written, buff, "00470");
261 
262   written = LIBC_NAMESPACE::sprintf(buff, "%05d", -581);
263   ASSERT_STREQ_LEN(written, buff, "-0581");
264 
265   // Combined Tests.
266 
267   written = LIBC_NAMESPACE::sprintf(buff, "%+ u", 692);
268   ASSERT_STREQ_LEN(written, buff, "692");
269 
270   written = LIBC_NAMESPACE::sprintf(buff, "%+ -05d", 703);
271   ASSERT_STREQ_LEN(written, buff, "+703 ");
272 
273   written = LIBC_NAMESPACE::sprintf(buff, "%7.5d", 814);
274   ASSERT_STREQ_LEN(written, buff, "  00814");
275 
276   written = LIBC_NAMESPACE::sprintf(buff, "%7.5d", -925);
277   ASSERT_STREQ_LEN(written, buff, " -00925");
278 
279   written = LIBC_NAMESPACE::sprintf(buff, "%7.5d", 159);
280   ASSERT_STREQ_LEN(written, buff, "  00159");
281 
282   written = LIBC_NAMESPACE::sprintf(buff, "% -7.5d", 260);
283   ASSERT_STREQ_LEN(written, buff, " 00260 ");
284 
285   written = LIBC_NAMESPACE::sprintf(buff, "%5.4d", 10000);
286   ASSERT_STREQ_LEN(written, buff, "10000");
287 
288   // Multiple Conversion Tests.
289 
290   written = LIBC_NAMESPACE::sprintf(buff, "%10d %-10d", 456, -789);
291   ASSERT_STREQ_LEN(written, buff, "       456 -789      ");
292 
293   written = LIBC_NAMESPACE::sprintf(buff, "%-5.4d%+.4u", 75, 25);
294   ASSERT_STREQ_LEN(written, buff, "0075 0025");
295 
296   written = LIBC_NAMESPACE::sprintf(buff, "% 05hhi %+-0.5llu %-+ 06.3zd",
297                                     256 + 127, 68719476736ll, size_t(2));
298   ASSERT_STREQ_LEN(written, buff, " 0127 68719476736 +002  ");
299 }
300 
301 TEST(LlvmLibcSPrintfTest, HexConv) {
302   char buff[64];
303   int written;
304 
305   // Basic Tests.
306 
307   written = LIBC_NAMESPACE::sprintf(buff, "%x", 0x123a);
308   ASSERT_STREQ_LEN(written, buff, "123a");
309 
310   written = LIBC_NAMESPACE::sprintf(buff, "%X", 0x456b);
311   ASSERT_STREQ_LEN(written, buff, "456B");
312 
313   // Length Modifier Tests.
314 
315   written = LIBC_NAMESPACE::sprintf(buff, "%hhx", 0x10001);
316   ASSERT_STREQ_LEN(written, buff, "1");
317 
318   written = LIBC_NAMESPACE::sprintf(buff, "%llx", 0xffffffffffffffffull);
319   ASSERT_STREQ_LEN(written, buff, "ffffffffffffffff"); // ull max
320 
321   written = LIBC_NAMESPACE::sprintf(buff, "%tX", ~ptrdiff_t(0));
322   if (sizeof(ptrdiff_t) == 8) {
323     ASSERT_STREQ_LEN(written, buff, "FFFFFFFFFFFFFFFF");
324   } else if (sizeof(ptrdiff_t) == 4) {
325     ASSERT_STREQ_LEN(written, buff, "FFFFFFFF");
326   }
327 
328   // Min Width Tests.
329 
330   written = LIBC_NAMESPACE::sprintf(buff, "%4x", 0x789);
331   ASSERT_STREQ_LEN(written, buff, " 789");
332 
333   written = LIBC_NAMESPACE::sprintf(buff, "%2X", 0x987);
334   ASSERT_STREQ_LEN(written, buff, "987");
335 
336   // Precision Tests.
337 
338   written = LIBC_NAMESPACE::sprintf(buff, "%x", 0);
339   ASSERT_STREQ_LEN(written, buff, "0");
340 
341   written = LIBC_NAMESPACE::sprintf(buff, "%.0x", 0);
342   ASSERT_STREQ_LEN(written, buff, "");
343 
344   written = LIBC_NAMESPACE::sprintf(buff, "%.5x", 0x1F3);
345   ASSERT_STREQ_LEN(written, buff, "001f3");
346 
347   written = LIBC_NAMESPACE::sprintf(buff, "%.2x", 0x135);
348   ASSERT_STREQ_LEN(written, buff, "135");
349 
350   // Flag Tests.
351 
352   written = LIBC_NAMESPACE::sprintf(buff, "%-5x", 0x246);
353   ASSERT_STREQ_LEN(written, buff, "246  ");
354 
355   written = LIBC_NAMESPACE::sprintf(buff, "%#x", 0xd3f);
356   ASSERT_STREQ_LEN(written, buff, "0xd3f");
357 
358   written = LIBC_NAMESPACE::sprintf(buff, "%#x", 0);
359   ASSERT_STREQ_LEN(written, buff, "0");
360 
361   written = LIBC_NAMESPACE::sprintf(buff, "%#X", 0xE40);
362   ASSERT_STREQ_LEN(written, buff, "0XE40");
363 
364   written = LIBC_NAMESPACE::sprintf(buff, "%05x", 0x470);
365   ASSERT_STREQ_LEN(written, buff, "00470");
366 
367   written = LIBC_NAMESPACE::sprintf(buff, "%0#6x", 0x8c3);
368   ASSERT_STREQ_LEN(written, buff, "0x08c3");
369 
370   written = LIBC_NAMESPACE::sprintf(buff, "%-#6x", 0x5f0);
371   ASSERT_STREQ_LEN(written, buff, "0x5f0 ");
372 
373   // Combined Tests.
374 
375   written = LIBC_NAMESPACE::sprintf(buff, "%#-07x", 0x703);
376   ASSERT_STREQ_LEN(written, buff, "0x703  ");
377 
378   written = LIBC_NAMESPACE::sprintf(buff, "%7.5x", 0x814);
379   ASSERT_STREQ_LEN(written, buff, "  00814");
380 
381   written = LIBC_NAMESPACE::sprintf(buff, "%#9.5X", 0x9d4);
382   ASSERT_STREQ_LEN(written, buff, "  0X009D4");
383 
384   written = LIBC_NAMESPACE::sprintf(buff, "%#.x", 0);
385   ASSERT_STREQ_LEN(written, buff, "");
386 
387   written = LIBC_NAMESPACE::sprintf(buff, "%-7.5x", 0x260);
388   ASSERT_STREQ_LEN(written, buff, "00260  ");
389 
390   written = LIBC_NAMESPACE::sprintf(buff, "%5.4x", 0x10000);
391   ASSERT_STREQ_LEN(written, buff, "10000");
392 
393   // Multiple Conversion Tests.
394 
395   written = LIBC_NAMESPACE::sprintf(buff, "%10X %-#10x", 0x45b, 0x789);
396   ASSERT_STREQ_LEN(written, buff, "       45B 0x789     ");
397 
398   written = LIBC_NAMESPACE::sprintf(buff, "%-5.4x%#.4x", 0x75, 0x25);
399   ASSERT_STREQ_LEN(written, buff, "0075 0x0025");
400 
401   written = LIBC_NAMESPACE::sprintf(buff, "%04hhX %#.5llx %-6.3zX", 256 + 0x7f,
402                                     0x1000000000ll, size_t(2));
403   ASSERT_STREQ_LEN(written, buff, "007F 0x1000000000 002   ");
404 }
405 
406 TEST(LlvmLibcSPrintfTest, BinConv) {
407   char buff[64];
408   int written;
409 
410   // Basic Tests.
411 
412   written = LIBC_NAMESPACE::sprintf(buff, "%b", 42);
413   ASSERT_STREQ_LEN(written, buff, "101010");
414 
415   written = LIBC_NAMESPACE::sprintf(buff, "%B", 12081991);
416   ASSERT_STREQ_LEN(written, buff, "101110000101101101000111");
417 
418   // Min Width Tests.
419 
420   written = LIBC_NAMESPACE::sprintf(buff, "%10b", 0b101010);
421   ASSERT_STREQ_LEN(written, buff, "    101010");
422 
423   written = LIBC_NAMESPACE::sprintf(buff, "%2B", 0b101010);
424   ASSERT_STREQ_LEN(written, buff, "101010");
425 
426   // Precision Tests.
427 
428   written = LIBC_NAMESPACE::sprintf(buff, "%b", 0);
429   ASSERT_STREQ_LEN(written, buff, "0");
430 
431   written = LIBC_NAMESPACE::sprintf(buff, "%.0b", 0);
432   ASSERT_STREQ_LEN(written, buff, "");
433 
434   written = LIBC_NAMESPACE::sprintf(buff, "%.5b", 0b111);
435   ASSERT_STREQ_LEN(written, buff, "00111");
436 
437   written = LIBC_NAMESPACE::sprintf(buff, "%.2b", 0b111);
438   ASSERT_STREQ_LEN(written, buff, "111");
439 
440   written = LIBC_NAMESPACE::sprintf(buff, "%3b", 0b111);
441   ASSERT_STREQ_LEN(written, buff, "111");
442 
443   // Flag Tests.
444 
445   written = LIBC_NAMESPACE::sprintf(buff, "%-5b", 0b111);
446   ASSERT_STREQ_LEN(written, buff, "111  ");
447 
448   written = LIBC_NAMESPACE::sprintf(buff, "%#b", 0b111);
449   ASSERT_STREQ_LEN(written, buff, "0b111");
450 
451   written = LIBC_NAMESPACE::sprintf(buff, "%#b", 0);
452   ASSERT_STREQ_LEN(written, buff, "0");
453 
454   written = LIBC_NAMESPACE::sprintf(buff, "%#B", 0b111);
455   ASSERT_STREQ_LEN(written, buff, "0B111");
456 
457   written = LIBC_NAMESPACE::sprintf(buff, "%05b", 0b111);
458   ASSERT_STREQ_LEN(written, buff, "00111");
459 
460   written = LIBC_NAMESPACE::sprintf(buff, "%0#6b", 0b111);
461   ASSERT_STREQ_LEN(written, buff, "0b0111");
462 
463   written = LIBC_NAMESPACE::sprintf(buff, "%-#6b", 0b111);
464   ASSERT_STREQ_LEN(written, buff, "0b111 ");
465 
466   // Combined Tests.
467 
468   written = LIBC_NAMESPACE::sprintf(buff, "%#-07b", 0b111);
469   ASSERT_STREQ_LEN(written, buff, "0b111  ");
470 
471   written = LIBC_NAMESPACE::sprintf(buff, "%7.5b", 0b111);
472   ASSERT_STREQ_LEN(written, buff, "  00111");
473 
474   written = LIBC_NAMESPACE::sprintf(buff, "%#9.5B", 0b111);
475   ASSERT_STREQ_LEN(written, buff, "  0B00111");
476 
477   written = LIBC_NAMESPACE::sprintf(buff, "%#.b", 0);
478   ASSERT_STREQ_LEN(written, buff, "");
479 
480   written = LIBC_NAMESPACE::sprintf(buff, "%-7.5b", 0b111);
481   ASSERT_STREQ_LEN(written, buff, "00111  ");
482 
483   written = LIBC_NAMESPACE::sprintf(buff, "%5.4b", 0b1111);
484   ASSERT_STREQ_LEN(written, buff, " 1111");
485 
486   // Multiple Conversion Tests.
487 
488   written = LIBC_NAMESPACE::sprintf(buff, "%10B %-#10b", 0b101, 0b110);
489   ASSERT_STREQ_LEN(written, buff, "       101 0b110     ");
490 
491   written = LIBC_NAMESPACE::sprintf(buff, "%-5.4b%#.4b", 0b101, 0b110);
492   ASSERT_STREQ_LEN(written, buff, "0101 0b0110");
493 }
494 
495 TEST(LlvmLibcSPrintfTest, PointerConv) {
496   char buff[64];
497   int written;
498 
499   written = LIBC_NAMESPACE::sprintf(buff, "%p", nullptr);
500   ASSERT_STREQ_LEN(written, buff, "(nullptr)");
501 
502   written = LIBC_NAMESPACE::sprintf(buff, "%p", 0x1a2b3c4d);
503   ASSERT_STREQ_LEN(written, buff, "0x1a2b3c4d");
504 
505   if constexpr (sizeof(void *) > 4) {
506     written = LIBC_NAMESPACE::sprintf(buff, "%p", 0x1a2b3c4d5e6f7081);
507     ASSERT_STREQ_LEN(written, buff, "0x1a2b3c4d5e6f7081");
508   }
509 
510   written = LIBC_NAMESPACE::sprintf(buff, "%p", &written);
511   EXPECT_GT(written, 0);
512 
513   // Width tests:
514 
515   written = LIBC_NAMESPACE::sprintf(buff, "%20p", nullptr);
516   ASSERT_STREQ_LEN(written, buff, "           (nullptr)");
517 
518   written = LIBC_NAMESPACE::sprintf(buff, "%20p", 0x1a2b3c4d);
519   ASSERT_STREQ_LEN(written, buff, "          0x1a2b3c4d");
520 
521   // Flag tests:
522 
523   written = LIBC_NAMESPACE::sprintf(buff, "%-20p", nullptr);
524   ASSERT_STREQ_LEN(written, buff, "(nullptr)           ");
525 
526   written = LIBC_NAMESPACE::sprintf(buff, "%-20p", 0x1a2b3c4d);
527   ASSERT_STREQ_LEN(written, buff, "0x1a2b3c4d          ");
528 
529   // Using the 0 flag is technically undefined, but here we're following the
530   // convention of matching the behavior of %#x.
531   written = LIBC_NAMESPACE::sprintf(buff, "%020p", 0x1a2b3c4d);
532   ASSERT_STREQ_LEN(written, buff, "0x00000000001a2b3c4d");
533 
534   // Precision tests:
535   // These are all undefined behavior. The precision option is undefined for %p.
536 
537   // Precision specifies the number of characters for a string conversion.
538   written = LIBC_NAMESPACE::sprintf(buff, "%.5p", nullptr);
539   ASSERT_STREQ_LEN(written, buff, "(null");
540 
541   // Precision specifies the number of digits to be written for %x conversions,
542   // and the "0x" doesn't count as part of the digits.
543   written = LIBC_NAMESPACE::sprintf(buff, "%.20p", 0x1a2b3c4d);
544   ASSERT_STREQ_LEN(written, buff, "0x0000000000001a2b3c4d");
545 }
546 
547 TEST(LlvmLibcSPrintfTest, OctConv) {
548   char buff[64];
549   int written;
550 
551   // Basic Tests.
552 
553   written = LIBC_NAMESPACE::sprintf(buff, "%o", 01234);
554   ASSERT_STREQ_LEN(written, buff, "1234");
555 
556   written = LIBC_NAMESPACE::sprintf(buff, "%o", 04567);
557   ASSERT_STREQ_LEN(written, buff, "4567");
558 
559   // Length Modifier Tests.
560 
561   written = LIBC_NAMESPACE::sprintf(buff, "%hho", 0401);
562   ASSERT_STREQ_LEN(written, buff, "1");
563 
564   written = LIBC_NAMESPACE::sprintf(buff, "%llo", 01777777777777777777777ull);
565   ASSERT_STREQ_LEN(written, buff, "1777777777777777777777"); // ull max
566 
567   written = LIBC_NAMESPACE::sprintf(buff, "%to", ~ptrdiff_t(0));
568   if (sizeof(ptrdiff_t) == 8) {
569     ASSERT_STREQ_LEN(written, buff, "1777777777777777777777");
570   } else if (sizeof(ptrdiff_t) == 4) {
571     ASSERT_STREQ_LEN(written, buff, "37777777777");
572   }
573 
574   // Min Width Tests.
575 
576   written = LIBC_NAMESPACE::sprintf(buff, "%4o", 0701);
577   ASSERT_STREQ_LEN(written, buff, " 701");
578 
579   written = LIBC_NAMESPACE::sprintf(buff, "%2o", 0107);
580   ASSERT_STREQ_LEN(written, buff, "107");
581 
582   // Precision Tests.
583 
584   written = LIBC_NAMESPACE::sprintf(buff, "%o", 0);
585   ASSERT_STREQ_LEN(written, buff, "0");
586 
587   written = LIBC_NAMESPACE::sprintf(buff, "%.0o", 0);
588   ASSERT_STREQ_LEN(written, buff, "");
589 
590   written = LIBC_NAMESPACE::sprintf(buff, "%.5o", 0153);
591   ASSERT_STREQ_LEN(written, buff, "00153");
592 
593   written = LIBC_NAMESPACE::sprintf(buff, "%.2o", 0135);
594   ASSERT_STREQ_LEN(written, buff, "135");
595 
596   // Flag Tests.
597 
598   written = LIBC_NAMESPACE::sprintf(buff, "%-5o", 0246);
599   ASSERT_STREQ_LEN(written, buff, "246  ");
600 
601   written = LIBC_NAMESPACE::sprintf(buff, "%#o", 0234);
602   ASSERT_STREQ_LEN(written, buff, "0234");
603 
604   written = LIBC_NAMESPACE::sprintf(buff, "%#o", 0);
605   ASSERT_STREQ_LEN(written, buff, "0");
606 
607   written = LIBC_NAMESPACE::sprintf(buff, "%05o", 0470);
608   ASSERT_STREQ_LEN(written, buff, "00470");
609 
610   written = LIBC_NAMESPACE::sprintf(buff, "%0#6o", 0753);
611   ASSERT_STREQ_LEN(written, buff, "000753");
612 
613   written = LIBC_NAMESPACE::sprintf(buff, "%-#6o", 0642);
614   ASSERT_STREQ_LEN(written, buff, "0642  ");
615 
616   // Combined Tests.
617 
618   written = LIBC_NAMESPACE::sprintf(buff, "%#-07o", 0703);
619   ASSERT_STREQ_LEN(written, buff, "0703   ");
620 
621   written = LIBC_NAMESPACE::sprintf(buff, "%#.o", 0);
622   ASSERT_STREQ_LEN(written, buff, "0");
623 
624   written = LIBC_NAMESPACE::sprintf(buff, "%7.5o", 0314);
625   ASSERT_STREQ_LEN(written, buff, "  00314");
626 
627   written = LIBC_NAMESPACE::sprintf(buff, "%#9.5o", 0234);
628   ASSERT_STREQ_LEN(written, buff, "    00234");
629 
630   written = LIBC_NAMESPACE::sprintf(buff, "%-7.5o", 0260);
631   ASSERT_STREQ_LEN(written, buff, "00260  ");
632 
633   written = LIBC_NAMESPACE::sprintf(buff, "%5.4o", 010000);
634   ASSERT_STREQ_LEN(written, buff, "10000");
635 
636   // Multiple Conversion Tests.
637 
638   written = LIBC_NAMESPACE::sprintf(buff, "%10o %-#10o", 0456, 0123);
639   ASSERT_STREQ_LEN(written, buff, "       456 0123      ");
640 
641   written = LIBC_NAMESPACE::sprintf(buff, "%-5.4o%#.4o", 075, 025);
642   ASSERT_STREQ_LEN(written, buff, "0075 0025");
643 
644   written = LIBC_NAMESPACE::sprintf(buff, "%04hho %#.5llo %-6.3zo", 256 + 077,
645                                     01000000000000ll, size_t(2));
646   ASSERT_STREQ_LEN(written, buff, "0077 01000000000000 002   ");
647 }
648 
649 #ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
650 
651 TEST(LlvmLibcSPrintfTest, FloatHexExpConv) {
652   char buff[128];
653   int written;
654 
655   ForceRoundingMode r(RoundingMode::Nearest);
656   double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
657   double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
658   written = LIBC_NAMESPACE::sprintf(buff, "%a", 1.0);
659   ASSERT_STREQ_LEN(written, buff, "0x1p+0");
660 
661   written = LIBC_NAMESPACE::sprintf(buff, "%A", -1.0);
662   ASSERT_STREQ_LEN(written, buff, "-0X1P+0");
663 
664   written = LIBC_NAMESPACE::sprintf(buff, "%a", -0x1.abcdef12345p0);
665   ASSERT_STREQ_LEN(written, buff, "-0x1.abcdef12345p+0");
666 
667   written = LIBC_NAMESPACE::sprintf(buff, "%A", 0x1.abcdef12345p0);
668   ASSERT_STREQ_LEN(written, buff, "0X1.ABCDEF12345P+0");
669 
670   written = LIBC_NAMESPACE::sprintf(buff, "%a", 0.0);
671   ASSERT_STREQ_LEN(written, buff, "0x0p+0");
672 
673   written = LIBC_NAMESPACE::sprintf(buff, "%a", 1.0e100);
674   ASSERT_STREQ_LEN(written, buff, "0x1.249ad2594c37dp+332");
675 
676   written = LIBC_NAMESPACE::sprintf(buff, "%a", 0.1);
677   ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4");
678 
679   // Subnormal Tests.
680 
681   written = LIBC_NAMESPACE::sprintf(buff, "%a", 0x1.0p-1027);
682   ASSERT_STREQ_LEN(written, buff, "0x0.08p-1022");
683 
684   written = LIBC_NAMESPACE::sprintf(buff, "%a", 0x1.0p-1025);
685   ASSERT_STREQ_LEN(written, buff, "0x0.2p-1022");
686 
687   written = LIBC_NAMESPACE::sprintf(buff, "%a", 0x1.0p-1023);
688   ASSERT_STREQ_LEN(written, buff, "0x0.8p-1022");
689 
690   written = LIBC_NAMESPACE::sprintf(buff, "%a", 0x1.0p-1022);
691   ASSERT_STREQ_LEN(written, buff, "0x1p-1022");
692 
693   written = LIBC_NAMESPACE::sprintf(buff, "%a", 0x1.0p-1074);
694   ASSERT_STREQ_LEN(written, buff, "0x0.0000000000001p-1022");
695 
696   // Inf/Nan Tests.
697 
698   written = LIBC_NAMESPACE::sprintf(buff, "%a", inf);
699   ASSERT_STREQ_LEN(written, buff, "inf");
700 
701   written = LIBC_NAMESPACE::sprintf(buff, "%A", -inf);
702   ASSERT_STREQ_LEN(written, buff, "-INF");
703 
704   written = LIBC_NAMESPACE::sprintf(buff, "%a", nan);
705   ASSERT_STREQ_LEN(written, buff, "nan");
706 
707   written = LIBC_NAMESPACE::sprintf(buff, "%A", -nan);
708   ASSERT_STREQ_LEN(written, buff, "-NAN");
709 
710   // Length Modifier Tests.
711 
712   written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.1L);
713 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
714   ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7");
715 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
716   ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4");
717 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
718   ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4");
719 #endif
720 
721   written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e1000L);
722 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
723   ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318");
724 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
725   ASSERT_STREQ_LEN(written, buff, "inf");
726 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
727   ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321");
728 #endif
729 
730   written = LIBC_NAMESPACE::sprintf(buff, "%La", 1.0e-1000L);
731 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
732   ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325");
733 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
734   ASSERT_STREQ_LEN(written, buff, "0x0p+0");
735 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
736   ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322");
737 #endif
738 
739   // Min Width Tests.
740 
741   written = LIBC_NAMESPACE::sprintf(buff, "%15a", 1.0);
742   ASSERT_STREQ_LEN(written, buff, "         0x1p+0");
743 
744   written = LIBC_NAMESPACE::sprintf(buff, "%15a", -1.0);
745   ASSERT_STREQ_LEN(written, buff, "        -0x1p+0");
746 
747   written = LIBC_NAMESPACE::sprintf(buff, "%15a", 1.0e10);
748   ASSERT_STREQ_LEN(written, buff, " 0x1.2a05f2p+33");
749 
750   written = LIBC_NAMESPACE::sprintf(buff, "%15a", -1.0e10);
751   ASSERT_STREQ_LEN(written, buff, "-0x1.2a05f2p+33");
752 
753   written = LIBC_NAMESPACE::sprintf(buff, "%10a", 1.0e10);
754   ASSERT_STREQ_LEN(written, buff, "0x1.2a05f2p+33");
755 
756   written = LIBC_NAMESPACE::sprintf(buff, "%5a", inf);
757   ASSERT_STREQ_LEN(written, buff, "  inf");
758 
759   written = LIBC_NAMESPACE::sprintf(buff, "%5a", -nan);
760   ASSERT_STREQ_LEN(written, buff, " -nan");
761 
762   // Precision Tests.
763 
764   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 1.0);
765   ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
766 
767   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0.0);
768   ASSERT_STREQ_LEN(written, buff, "0x0.0p+0");
769 
770   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0.1);
771   ASSERT_STREQ_LEN(written, buff, "0x1.ap-4");
772 
773   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.0fp0);
774   ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
775 
776   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.07p0);
777   ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
778 
779   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.08p0);
780   ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
781 
782   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.18p0);
783   ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
784 
785   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.ffp0);
786   ASSERT_STREQ_LEN(written, buff, "0x2.0p+0");
787 
788   written = LIBC_NAMESPACE::sprintf(buff, "%.5a", 1.25);
789   ASSERT_STREQ_LEN(written, buff, "0x1.40000p+0");
790 
791   written = LIBC_NAMESPACE::sprintf(buff, "%.0a", 1.25);
792   ASSERT_STREQ_LEN(written, buff, "0x1p+0");
793 
794   written = LIBC_NAMESPACE::sprintf(buff, "%.0a", 1.75);
795   ASSERT_STREQ_LEN(written, buff, "0x2p+0");
796 
797   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.0p-1023);
798   ASSERT_STREQ_LEN(written, buff, "0x0.8p-1022");
799 
800   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.8p-1023);
801   ASSERT_STREQ_LEN(written, buff, "0x0.cp-1022");
802 
803   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.0p-1024);
804   ASSERT_STREQ_LEN(written, buff, "0x0.4p-1022");
805 
806   written = LIBC_NAMESPACE::sprintf(buff, "%.0a", 0x1.0p-1023);
807   ASSERT_STREQ_LEN(written, buff, "0x0p-1022");
808 
809   written = LIBC_NAMESPACE::sprintf(buff, "%.0a", 0x1.8p-1023);
810   ASSERT_STREQ_LEN(written, buff, "0x1p-1022");
811 
812   written = LIBC_NAMESPACE::sprintf(buff, "%.0a", 0x1.0p-1024);
813   ASSERT_STREQ_LEN(written, buff, "0x0p-1022");
814 
815   written = LIBC_NAMESPACE::sprintf(buff, "%.2a", 0x1.0p-1027);
816   ASSERT_STREQ_LEN(written, buff, "0x0.08p-1022");
817 
818   written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.0p-1027);
819   ASSERT_STREQ_LEN(written, buff, "0x0.0p-1022");
820 
821   written = LIBC_NAMESPACE::sprintf(buff, "%.5a", 0.0);
822   ASSERT_STREQ_LEN(written, buff, "0x0.00000p+0");
823 
824   written = LIBC_NAMESPACE::sprintf(buff, "%.5a", 0x1.008p0);
825   ASSERT_STREQ_LEN(written, buff, "0x1.00800p+0");
826 
827   written = LIBC_NAMESPACE::sprintf(buff, "%.5a", 0x1.008p10);
828   ASSERT_STREQ_LEN(written, buff, "0x1.00800p+10");
829 
830   written = LIBC_NAMESPACE::sprintf(buff, "%.5a", nan);
831   ASSERT_STREQ_LEN(written, buff, "nan");
832 
833   written = LIBC_NAMESPACE::sprintf(buff, "%La", 0.0L);
834   ASSERT_STREQ_LEN(written, buff, "0x0p+0");
835 
836   written = LIBC_NAMESPACE::sprintf(buff, "%.1La", 0.1L);
837 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
838   ASSERT_STREQ_LEN(written, buff, "0xc.dp-7");
839 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
840   ASSERT_STREQ_LEN(written, buff, "0x1.ap-4");
841 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
842   ASSERT_STREQ_LEN(written, buff, "0x1.ap-4");
843 #endif
844 
845   written = LIBC_NAMESPACE::sprintf(buff, "%.1La", 0xf.fffffffffffffffp16380L);
846 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
847   ASSERT_STREQ_LEN(written, buff, "0x1.0p+16384");
848 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
849   ASSERT_STREQ_LEN(written, buff, "inf");
850 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
851   ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
852 #endif
853 
854   // Rounding Mode Tests.
855 
856   if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
857     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.08p0);
858     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
859 
860     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.18p0);
861     ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
862 
863     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.04p0);
864     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
865 
866     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.14p0);
867     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
868 
869     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.08p0);
870     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
871 
872     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.18p0);
873     ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
874 
875     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.04p0);
876     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
877 
878     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.14p0);
879     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
880   }
881 
882   if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
883     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.08p0);
884     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
885 
886     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.18p0);
887     ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
888 
889     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.04p0);
890     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
891 
892     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.14p0);
893     ASSERT_STREQ_LEN(written, buff, "0x1.2p+0");
894 
895     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.08p0);
896     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
897 
898     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.18p0);
899     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
900 
901     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.04p0);
902     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
903 
904     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.14p0);
905     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
906   }
907 
908   if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
909     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.08p0);
910     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
911 
912     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.18p0);
913     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
914 
915     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.04p0);
916     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
917 
918     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.14p0);
919     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
920 
921     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.08p0);
922     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
923 
924     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.18p0);
925     ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
926 
927     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.04p0);
928     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
929 
930     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.14p0);
931     ASSERT_STREQ_LEN(written, buff, "-0x1.2p+0");
932   }
933 
934   if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
935     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.08p0);
936     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
937 
938     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.18p0);
939     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
940 
941     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.04p0);
942     ASSERT_STREQ_LEN(written, buff, "0x1.0p+0");
943 
944     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", 0x1.14p0);
945     ASSERT_STREQ_LEN(written, buff, "0x1.1p+0");
946 
947     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.08p0);
948     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
949 
950     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.18p0);
951     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
952 
953     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.04p0);
954     ASSERT_STREQ_LEN(written, buff, "-0x1.0p+0");
955 
956     written = LIBC_NAMESPACE::sprintf(buff, "%.1a", -0x1.14p0);
957     ASSERT_STREQ_LEN(written, buff, "-0x1.1p+0");
958   }
959 
960   // Flag Tests.
961 
962   written = LIBC_NAMESPACE::sprintf(buff, "%+a", nan);
963   ASSERT_STREQ_LEN(written, buff, "+nan");
964 
965   written = LIBC_NAMESPACE::sprintf(buff, "% A", inf);
966   ASSERT_STREQ_LEN(written, buff, " INF");
967 
968   written = LIBC_NAMESPACE::sprintf(buff, "%-5a", inf);
969   ASSERT_STREQ_LEN(written, buff, "inf  ");
970 
971   written = LIBC_NAMESPACE::sprintf(buff, "%+-5A", nan);
972   ASSERT_STREQ_LEN(written, buff, "+NAN ");
973 
974   written = LIBC_NAMESPACE::sprintf(buff, "%+a", 1.0);
975   ASSERT_STREQ_LEN(written, buff, "+0x1p+0");
976 
977   written = LIBC_NAMESPACE::sprintf(buff, "% a", 0.0);
978   ASSERT_STREQ_LEN(written, buff, " 0x0p+0");
979 
980   written = LIBC_NAMESPACE::sprintf(buff, "%-10a", 1.5);
981   ASSERT_STREQ_LEN(written, buff, "0x1.8p+0  ");
982 
983   written = LIBC_NAMESPACE::sprintf(buff, "%#a", 1.0);
984   ASSERT_STREQ_LEN(written, buff, "0x1.p+0");
985 
986   written = LIBC_NAMESPACE::sprintf(buff, "%#.0a", 1.5);
987   ASSERT_STREQ_LEN(written, buff, "0x2.p+0");
988 
989   written = LIBC_NAMESPACE::sprintf(buff, "%010a", 1.5);
990   ASSERT_STREQ_LEN(written, buff, "0x001.8p+0");
991 
992   written = LIBC_NAMESPACE::sprintf(buff, "%+- #0a", 0.0);
993   ASSERT_STREQ_LEN(written, buff, "+0x0.p+0");
994 
995   // Combined Tests.
996 
997   written = LIBC_NAMESPACE::sprintf(buff, "%12.3a %-12.3A", 0.1, 256.0);
998   ASSERT_STREQ_LEN(written, buff, "  0x1.99ap-4 0X1.000P+8  ");
999 
1000   written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3a % 012.3a", 0.1256, 1256.0);
1001   ASSERT_STREQ_LEN(written, buff, "+0x1.014p-3   0x1.3a0p+10");
1002 
1003   // These tests check that the padding is properly calculated based on the
1004   // min_width field. Specifically, they check that the extra zeroes added by
1005   // the high precision are accounted for correctly.
1006   written = LIBC_NAMESPACE::sprintf(buff, "%50.50a", 0x1.0p0);
1007   ASSERT_STREQ_LEN(written, buff,
1008                    "0x1.00000000000000000000000000000000000000000000000000p+0");
1009 
1010   // The difference with this test is that the formatted number is exactly 57
1011   // characters, so padding to 58 adds a space.
1012   written = LIBC_NAMESPACE::sprintf(buff, "%58.50a", 0x1.0p0);
1013   ASSERT_STREQ_LEN(
1014       written, buff,
1015       " 0x1.00000000000000000000000000000000000000000000000000p+0");
1016 }
1017 
1018 TEST(LlvmLibcSPrintfTest, FloatDecimalConv) {
1019   char buff[1500];
1020   int written;
1021 
1022   ForceRoundingMode r(RoundingMode::Nearest);
1023   double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
1024   double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
1025   long double ld_inf =
1026       LIBC_NAMESPACE::fputil::FPBits<long double>::inf().get_val();
1027   long double ld_nan =
1028       LIBC_NAMESPACE::fputil::FPBits<long double>::quiet_nan().get_val();
1029 
1030   written = LIBC_NAMESPACE::sprintf(buff, "%f", 1.0);
1031   ASSERT_STREQ_LEN(written, buff, "1.000000");
1032 
1033   written = LIBC_NAMESPACE::sprintf(buff, "%F", -1.0);
1034   ASSERT_STREQ_LEN(written, buff, "-1.000000");
1035 
1036   written = LIBC_NAMESPACE::sprintf(buff, "%f", -1.234567);
1037   ASSERT_STREQ_LEN(written, buff, "-1.234567");
1038 
1039   written = LIBC_NAMESPACE::sprintf(buff, "%f", 0.0);
1040   ASSERT_STREQ_LEN(written, buff, "0.000000");
1041 
1042   written = LIBC_NAMESPACE::sprintf(buff, "%f", 1.5);
1043   ASSERT_STREQ_LEN(written, buff, "1.500000");
1044 
1045 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1046   written = LIBC_NAMESPACE::sprintf(buff, "%f", 1e300);
1047   ASSERT_STREQ_LEN(
1048       written, buff,
1049       "100000000000000005250476025520442024870446858110815915491585411551180245"
1050       "798890819578637137508044786404370444383288387817694252323536043057564479"
1051       "218478670698284838720092657580373783023379478809005936895323497079994508"
1052       "111903896764088007465274278014249457925878882005684283811566947219638686"
1053       "5459400540160.000000");
1054 #endif // LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1055 
1056   written = LIBC_NAMESPACE::sprintf(buff, "%f", 0.1);
1057   ASSERT_STREQ_LEN(written, buff, "0.100000");
1058 
1059   written = LIBC_NAMESPACE::sprintf(buff, "%f", 1234567890123456789.0);
1060   ASSERT_STREQ_LEN(written, buff, "1234567890123456768.000000");
1061 
1062   written = LIBC_NAMESPACE::sprintf(buff, "%f", 9999999999999.99);
1063   ASSERT_STREQ_LEN(written, buff, "9999999999999.990234");
1064 
1065   // Simple Subnormal Tests.
1066 
1067   written = LIBC_NAMESPACE::sprintf(buff, "%f", 0x1.0p-1027);
1068   ASSERT_STREQ_LEN(written, buff, "0.000000");
1069 
1070   written = LIBC_NAMESPACE::sprintf(buff, "%f", 0x1.0p-1074);
1071   ASSERT_STREQ_LEN(written, buff, "0.000000");
1072 
1073   // Inf/Nan Tests.
1074 
1075   written = LIBC_NAMESPACE::sprintf(buff, "%f", inf);
1076   ASSERT_STREQ_LEN(written, buff, "inf");
1077 
1078   written = LIBC_NAMESPACE::sprintf(buff, "%F", -inf);
1079   ASSERT_STREQ_LEN(written, buff, "-INF");
1080 
1081   written = LIBC_NAMESPACE::sprintf(buff, "%f", nan);
1082   ASSERT_STREQ_LEN(written, buff, "nan");
1083 
1084   written = LIBC_NAMESPACE::sprintf(buff, "%F", -nan);
1085   ASSERT_STREQ_LEN(written, buff, "-NAN");
1086 
1087   written = LIBC_NAMESPACE::sprintf(buff, "%Lf", ld_inf);
1088   ASSERT_STREQ_LEN(written, buff, "inf");
1089 
1090   written = LIBC_NAMESPACE::sprintf(buff, "%LF", -ld_inf);
1091   ASSERT_STREQ_LEN(written, buff, "-INF");
1092 
1093   written = LIBC_NAMESPACE::sprintf(buff, "%Lf", ld_nan);
1094   ASSERT_STREQ_LEN(written, buff, "nan");
1095 
1096 // Some float128 systems (specifically the ones used for aarch64 buildbots)
1097 // don't respect signs for long double NaNs.
1098 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80) ||                          \
1099     defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
1100   written = LIBC_NAMESPACE::sprintf(buff, "%LF", -ld_nan);
1101   ASSERT_STREQ_LEN(written, buff, "-NAN");
1102 #endif
1103 
1104   // Min Width Tests.
1105 
1106   written = LIBC_NAMESPACE::sprintf(buff, "%15f", 1.0);
1107   ASSERT_STREQ_LEN(written, buff, "       1.000000");
1108 
1109   written = LIBC_NAMESPACE::sprintf(buff, "%15f", -1.0);
1110   ASSERT_STREQ_LEN(written, buff, "      -1.000000");
1111 
1112   written = LIBC_NAMESPACE::sprintf(buff, "%15f", 1.0e5);
1113   ASSERT_STREQ_LEN(written, buff, "  100000.000000");
1114 
1115   written = LIBC_NAMESPACE::sprintf(buff, "%15f", -1.0e5);
1116   ASSERT_STREQ_LEN(written, buff, " -100000.000000");
1117 
1118   written = LIBC_NAMESPACE::sprintf(buff, "%10f", 1.0e5);
1119   ASSERT_STREQ_LEN(written, buff, "100000.000000");
1120 
1121   // Precision Tests.
1122 
1123   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.0);
1124   ASSERT_STREQ_LEN(written, buff, "1.0");
1125 
1126   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0.0);
1127   ASSERT_STREQ_LEN(written, buff, "0.0");
1128 
1129   written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 0.0);
1130   ASSERT_STREQ_LEN(written, buff, "0");
1131 
1132   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0.1);
1133   ASSERT_STREQ_LEN(written, buff, "0.1");
1134 
1135   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.09);
1136   ASSERT_STREQ_LEN(written, buff, "1.1");
1137 
1138   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.04);
1139   ASSERT_STREQ_LEN(written, buff, "1.0");
1140 
1141   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.19);
1142   ASSERT_STREQ_LEN(written, buff, "1.2");
1143 
1144   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.99);
1145   ASSERT_STREQ_LEN(written, buff, "2.0");
1146 
1147   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 9.99);
1148   ASSERT_STREQ_LEN(written, buff, "10.0");
1149 
1150   written = LIBC_NAMESPACE::sprintf(buff, "%.2f", 9999999999999.99);
1151   ASSERT_STREQ_LEN(written, buff, "9999999999999.99");
1152 
1153   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 9999999999999.99);
1154   ASSERT_STREQ_LEN(written, buff, "10000000000000.0");
1155 
1156   written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.25);
1157   ASSERT_STREQ_LEN(written, buff, "1.25000");
1158 
1159   written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 1.25);
1160   ASSERT_STREQ_LEN(written, buff, "1");
1161 
1162   written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 1.75);
1163   ASSERT_STREQ_LEN(written, buff, "2");
1164 
1165   written = LIBC_NAMESPACE::sprintf(buff, "%.20f", 1.234e-10);
1166   ASSERT_STREQ_LEN(written, buff, "0.00000000012340000000");
1167 
1168   written = LIBC_NAMESPACE::sprintf(buff, "%.2f", -9.99);
1169   ASSERT_STREQ_LEN(written, buff, "-9.99");
1170 
1171   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -9.99);
1172   ASSERT_STREQ_LEN(written, buff, "-10.0");
1173 
1174   written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 0.0);
1175   ASSERT_STREQ_LEN(written, buff, "0.00000");
1176 
1177   written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.008);
1178   ASSERT_STREQ_LEN(written, buff, "1.00800");
1179 
1180   written = LIBC_NAMESPACE::sprintf(buff, "%.5f", 1.008e3);
1181   ASSERT_STREQ_LEN(written, buff, "1008.00000");
1182 
1183   // Found with the help of Fred Tydeman's tbin2dec test.
1184   written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 0x1.1000000000006p+3);
1185   ASSERT_STREQ_LEN(written, buff, "8.5");
1186 
1187   written = LIBC_NAMESPACE::sprintf(buff, "%.0f", 0x1.1000000000006p+3);
1188   ASSERT_STREQ_LEN(written, buff, "9");
1189 
1190   // Most of these tests are checking rounding behavior when the precision is
1191   // set. As an example, %.9f has a precision of 9, meaning it should be rounded
1192   // to 9 digits after the decimal point. In this case, that means that it
1193   // should be rounded up. Many of these tests have precisions divisible by 9
1194   // since when printing the floating point numbers are broken up into "blocks"
1195   // of 9 digits. They often also have a 5 after the end of what's printed,
1196   // since in round to nearest mode, that requires checking additional digits.
1197   written = LIBC_NAMESPACE::sprintf(buff, "%.9f", 1.9999999999999514);
1198   ASSERT_STREQ_LEN(written, buff, "2.000000000");
1199 
1200 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1201   // The number continues after the literal because floating point numbers can't
1202   // represent every value. The printed value is the closest value a double can
1203   // represent, rounded to the requested precision.
1204   written = LIBC_NAMESPACE::sprintf(buff, "%.238f", 1.131959884853339E-72);
1205   ASSERT_STREQ_LEN(
1206       written, buff,
1207       "0."
1208       "000000000000000000000000000000000000000000000000000000000000000000000001"
1209       "131959884853339045938639911360973972585316399767392273697826861241937664"
1210       "824105639342441431495119762431744054912109728706985341609159156917030486"
1211       "5110665559768676757812");
1212 #endif
1213 
1214   written = LIBC_NAMESPACE::sprintf(buff, "%.36f", 9.9e-77);
1215   ASSERT_STREQ_LEN(written, buff, "0.000000000000000000000000000000000000");
1216 
1217 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1218   written = LIBC_NAMESPACE::sprintf(buff, "%.1071f", 2.0226568751604562E-314);
1219   ASSERT_STREQ_LEN(
1220       written, buff,
1221       "0."
1222       "000000000000000000000000000000000000000000000000000000000000000000000000"
1223       "000000000000000000000000000000000000000000000000000000000000000000000000"
1224       "000000000000000000000000000000000000000000000000000000000000000000000000"
1225       "000000000000000000000000000000000000000000000000000000000000000000000000"
1226       "000000000000000000000000020226568751604561683387695750739190248658016786"
1227       "876938365740768295004457513021760887468117675879956193821375945376632621"
1228       "367998639317487303530427946024002091961988296562516210434394107910027236"
1229       "308233439098296717697919471698168200340836487924061502604112643734560622"
1230       "258525943451473162532620033398739382796482175564084902819878893430369431"
1231       "907237673154867595954110791891883281880339550955455702452422857027182100"
1232       "606009588295886640782228837851739241290179512817803196347460636150182981"
1233       "085084829941917048152725177119574542042352896161225179181967347829576272"
1234       "242480201291872969114441104973910102402751449901108484914924879541248714"
1235       "939096548775588293353689592872854495101242645279589976452453829724479805"
1236       "750016448075109469332839157162950982637994457036256790161132812");
1237 #endif
1238 
1239   // If no precision is specified it defaults to 6 for %f.
1240   written = LIBC_NAMESPACE::sprintf(buff, "%f", 2325885.4901960781);
1241   ASSERT_STREQ_LEN(written, buff, "2325885.490196");
1242 
1243   // Subnormal Precision Tests
1244 
1245   written = LIBC_NAMESPACE::sprintf(buff, "%.310f", 0x1.0p-1022);
1246   ASSERT_STREQ_LEN(
1247       written, buff,
1248       "0."
1249       "000000000000000000000000000000000000000000000000000000000000000000000000"
1250       "000000000000000000000000000000000000000000000000000000000000000000000000"
1251       "000000000000000000000000000000000000000000000000000000000000000000000000"
1252       "000000000000000000000000000000000000000000000000000000000000000000000000"
1253       "0000000000000000000223");
1254 
1255   written = LIBC_NAMESPACE::sprintf(buff, "%.310f", 0x1.0p-1023);
1256   ASSERT_STREQ_LEN(
1257       written, buff,
1258       "0."
1259       "000000000000000000000000000000000000000000000000000000000000000000000000"
1260       "000000000000000000000000000000000000000000000000000000000000000000000000"
1261       "000000000000000000000000000000000000000000000000000000000000000000000000"
1262       "000000000000000000000000000000000000000000000000000000000000000000000000"
1263       "0000000000000000000111");
1264 
1265   written = LIBC_NAMESPACE::sprintf(buff, "%.315f", 9.99999e-310);
1266   ASSERT_STREQ_LEN(
1267       written, buff,
1268       "0."
1269       "000000000000000000000000000000000000000000000000000000000000000000000000"
1270       "000000000000000000000000000000000000000000000000000000000000000000000000"
1271       "000000000000000000000000000000000000000000000000000000000000000000000000"
1272       "000000000000000000000000000000000000000000000000000000000000000000000000"
1273       "000000000000000000000999999");
1274 
1275   written = LIBC_NAMESPACE::sprintf(buff, "%.314f", 9.99999e-310);
1276   ASSERT_STREQ_LEN(
1277       written, buff,
1278       "0."
1279       "000000000000000000000000000000000000000000000000000000000000000000000000"
1280       "000000000000000000000000000000000000000000000000000000000000000000000000"
1281       "000000000000000000000000000000000000000000000000000000000000000000000000"
1282       "000000000000000000000000000000000000000000000000000000000000000000000000"
1283       "00000000000000000000100000");
1284 
1285   written = LIBC_NAMESPACE::sprintf(buff, "%.330f", 0x1.0p-1074);
1286   ASSERT_STREQ_LEN(
1287       written, buff,
1288       "0."
1289       "000000000000000000000000000000000000000000000000000000000000000000000000"
1290       "000000000000000000000000000000000000000000000000000000000000000000000000"
1291       "000000000000000000000000000000000000000000000000000000000000000000000000"
1292       "000000000000000000000000000000000000000000000000000000000000000000000000"
1293       "000000000000000000000000000000000004940656");
1294 
1295   // Rounding Mode Tests.
1296 
1297   if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
1298     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.75);
1299     ASSERT_STREQ_LEN(written, buff, "1.8");
1300 
1301     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.25);
1302     ASSERT_STREQ_LEN(written, buff, "1.2");
1303 
1304     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.125);
1305     ASSERT_STREQ_LEN(written, buff, "1.1");
1306 
1307     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.625);
1308     ASSERT_STREQ_LEN(written, buff, "1.6");
1309 
1310     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.375);
1311     ASSERT_STREQ_LEN(written, buff, "1.4");
1312 
1313     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.875);
1314     ASSERT_STREQ_LEN(written, buff, "1.9");
1315 
1316     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.75);
1317     ASSERT_STREQ_LEN(written, buff, "-1.8");
1318 
1319     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.25);
1320     ASSERT_STREQ_LEN(written, buff, "-1.2");
1321 
1322     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.125);
1323     ASSERT_STREQ_LEN(written, buff, "-1.1");
1324 
1325     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.625);
1326     ASSERT_STREQ_LEN(written, buff, "-1.6");
1327 
1328     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.375);
1329     ASSERT_STREQ_LEN(written, buff, "-1.4");
1330 
1331     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.875);
1332     ASSERT_STREQ_LEN(written, buff, "-1.9");
1333   }
1334 
1335   if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
1336     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.75);
1337     ASSERT_STREQ_LEN(written, buff, "1.8");
1338 
1339     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.25);
1340     ASSERT_STREQ_LEN(written, buff, "1.3");
1341 
1342     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.125);
1343     ASSERT_STREQ_LEN(written, buff, "1.2");
1344 
1345     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.625);
1346     ASSERT_STREQ_LEN(written, buff, "1.7");
1347 
1348     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.375);
1349     ASSERT_STREQ_LEN(written, buff, "1.4");
1350 
1351     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.875);
1352     ASSERT_STREQ_LEN(written, buff, "1.9");
1353 
1354     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.75);
1355     ASSERT_STREQ_LEN(written, buff, "-1.7");
1356 
1357     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.25);
1358     ASSERT_STREQ_LEN(written, buff, "-1.2");
1359 
1360     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.125);
1361     ASSERT_STREQ_LEN(written, buff, "-1.1");
1362 
1363     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.625);
1364     ASSERT_STREQ_LEN(written, buff, "-1.6");
1365 
1366     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.375);
1367     ASSERT_STREQ_LEN(written, buff, "-1.3");
1368 
1369     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.875);
1370     ASSERT_STREQ_LEN(written, buff, "-1.8");
1371   }
1372 
1373   if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
1374     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.75);
1375     ASSERT_STREQ_LEN(written, buff, "1.7");
1376 
1377     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.25);
1378     ASSERT_STREQ_LEN(written, buff, "1.2");
1379 
1380     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.125);
1381     ASSERT_STREQ_LEN(written, buff, "1.1");
1382 
1383     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.625);
1384     ASSERT_STREQ_LEN(written, buff, "1.6");
1385 
1386     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.375);
1387     ASSERT_STREQ_LEN(written, buff, "1.3");
1388 
1389     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.875);
1390     ASSERT_STREQ_LEN(written, buff, "1.8");
1391 
1392     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.75);
1393     ASSERT_STREQ_LEN(written, buff, "-1.8");
1394 
1395     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.25);
1396     ASSERT_STREQ_LEN(written, buff, "-1.3");
1397 
1398     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.125);
1399     ASSERT_STREQ_LEN(written, buff, "-1.2");
1400 
1401     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.625);
1402     ASSERT_STREQ_LEN(written, buff, "-1.7");
1403 
1404     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.375);
1405     ASSERT_STREQ_LEN(written, buff, "-1.4");
1406 
1407     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.875);
1408     ASSERT_STREQ_LEN(written, buff, "-1.9");
1409   }
1410 
1411   if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
1412     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.75);
1413     ASSERT_STREQ_LEN(written, buff, "1.7");
1414 
1415     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.25);
1416     ASSERT_STREQ_LEN(written, buff, "1.2");
1417 
1418     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.125);
1419     ASSERT_STREQ_LEN(written, buff, "1.1");
1420 
1421     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.625);
1422     ASSERT_STREQ_LEN(written, buff, "1.6");
1423 
1424     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.375);
1425     ASSERT_STREQ_LEN(written, buff, "1.3");
1426 
1427     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", 1.875);
1428     ASSERT_STREQ_LEN(written, buff, "1.8");
1429 
1430     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.75);
1431     ASSERT_STREQ_LEN(written, buff, "-1.7");
1432 
1433     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.25);
1434     ASSERT_STREQ_LEN(written, buff, "-1.2");
1435 
1436     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.125);
1437     ASSERT_STREQ_LEN(written, buff, "-1.1");
1438 
1439     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.625);
1440     ASSERT_STREQ_LEN(written, buff, "-1.6");
1441 
1442     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.375);
1443     ASSERT_STREQ_LEN(written, buff, "-1.3");
1444 
1445     written = LIBC_NAMESPACE::sprintf(buff, "%.1f", -1.875);
1446     ASSERT_STREQ_LEN(written, buff, "-1.8");
1447   }
1448 
1449   // Flag Tests.
1450   written = LIBC_NAMESPACE::sprintf(buff, "%+f", 1.0);
1451   ASSERT_STREQ_LEN(written, buff, "+1.000000");
1452 
1453   written = LIBC_NAMESPACE::sprintf(buff, "%+f", -1.0);
1454   ASSERT_STREQ_LEN(written, buff, "-1.000000");
1455 
1456   written = LIBC_NAMESPACE::sprintf(buff, "% f", 1.0);
1457   ASSERT_STREQ_LEN(written, buff, " 1.000000");
1458 
1459   written = LIBC_NAMESPACE::sprintf(buff, "% f", -1.0);
1460   ASSERT_STREQ_LEN(written, buff, "-1.000000");
1461 
1462   written = LIBC_NAMESPACE::sprintf(buff, "%-10f", 1.5);
1463   ASSERT_STREQ_LEN(written, buff, "1.500000  ");
1464 
1465   written = LIBC_NAMESPACE::sprintf(buff, "%#.f", 1.0);
1466   ASSERT_STREQ_LEN(written, buff, "1.");
1467 
1468   written = LIBC_NAMESPACE::sprintf(buff, "%#.0f", 1.5);
1469   ASSERT_STREQ_LEN(written, buff, "2.");
1470 
1471   written = LIBC_NAMESPACE::sprintf(buff, "%010f", 1.5);
1472   ASSERT_STREQ_LEN(written, buff, "001.500000");
1473 
1474   written = LIBC_NAMESPACE::sprintf(buff, "%010f", -1.5);
1475   ASSERT_STREQ_LEN(written, buff, "-01.500000");
1476 
1477   written = LIBC_NAMESPACE::sprintf(buff, "%+- #0f", 0.0);
1478   ASSERT_STREQ_LEN(written, buff, "+0.000000");
1479 
1480   // Combined Tests.
1481 
1482   written = LIBC_NAMESPACE::sprintf(buff, "%10.2f", 9.99);
1483   ASSERT_STREQ_LEN(written, buff, "      9.99");
1484 
1485   written = LIBC_NAMESPACE::sprintf(buff, "%5.1f", 9.99);
1486   ASSERT_STREQ_LEN(written, buff, " 10.0");
1487 
1488   written = LIBC_NAMESPACE::sprintf(buff, "%-10.2f", 9.99);
1489   ASSERT_STREQ_LEN(written, buff, "9.99      ");
1490 
1491   written = LIBC_NAMESPACE::sprintf(buff, "%-5.1f", 9.99);
1492   ASSERT_STREQ_LEN(written, buff, "10.0 ");
1493 
1494   written = LIBC_NAMESPACE::sprintf(buff, "%-5.1f", 1.0e-50);
1495   ASSERT_STREQ_LEN(written, buff, "0.0  ");
1496 
1497   written = LIBC_NAMESPACE::sprintf(buff, "%30f", 1234567890123456789.0);
1498   ASSERT_STREQ_LEN(written, buff, "    1234567890123456768.000000");
1499 
1500   written = LIBC_NAMESPACE::sprintf(buff, "%-30f", 1234567890123456789.0);
1501   ASSERT_STREQ_LEN(written, buff, "1234567890123456768.000000    ");
1502 
1503   written = LIBC_NAMESPACE::sprintf(buff, "%20.2f", 9999999999999.99);
1504   ASSERT_STREQ_LEN(written, buff, "    9999999999999.99");
1505 
1506   written = LIBC_NAMESPACE::sprintf(buff, "%20.1f", 9999999999999.99);
1507   ASSERT_STREQ_LEN(written, buff, "    10000000000000.0");
1508 
1509   written = LIBC_NAMESPACE::sprintf(buff, "%12.3f %-12.3f", 0.1, 256.0);
1510   ASSERT_STREQ_LEN(written, buff, "       0.100 256.000     ");
1511 
1512   written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3f % 012.3f", 0.1256, 1256.0);
1513   ASSERT_STREQ_LEN(written, buff, "+0.126        0001256.000");
1514 }
1515 
1516 // The long double tests are separated so that their performance can be directly
1517 // measured.
1518 TEST(LlvmLibcSPrintfTest, FloatDecimalLongDoubleConv) {
1519   char buff[1000];
1520   int written;
1521 
1522   ForceRoundingMode r(RoundingMode::Nearest);
1523 
1524   // Length Modifier Tests.
1525 
1526   // TODO(michaelrj): Add tests for LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64 and 128
1527   // bit long double systems.
1528   // TODO(michaelrj): Fix the tests to only depend on the digits the long double
1529   // is accurate for.
1530 
1531   written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1.0L);
1532   ASSERT_STREQ_LEN(written, buff, "1.000000");
1533 
1534   written = LIBC_NAMESPACE::sprintf(buff, "%.Lf", -2.5L);
1535   ASSERT_STREQ_LEN(written, buff, "-2");
1536 
1537 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
1538 
1539 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1540   written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 1e100L);
1541   ASSERT_STREQ_LEN(written, buff,
1542                    "99999999999999999996693535322073426194986990198284960792713"
1543                    "91541752018669482644324418977840117055488.000000");
1544 #endif
1545 
1546   written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 0xd.96ed1192687859ap-24L);
1547   ASSERT_STREQ_LEN(written, buff, "0.000001");
1548 
1549   written = LIBC_NAMESPACE::sprintf(buff, "%Lf", 10000000000000000.25L);
1550   ASSERT_STREQ_LEN(written, buff, "10000000000000000.250000");
1551 
1552 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1553   written = LIBC_NAMESPACE::sprintf(buff, "%.510Lf", 0x8p-503L);
1554   ASSERT_STREQ_LEN(
1555       written, buff,
1556       "0."
1557       "000000000000000000000000000000000000000000000000000000000000000000000000"
1558       "000000000000000000000000000000000000000000000000000000000000000000000000"
1559       "000000305493636349960468205197939321361769978940274057232666389361390928"
1560       "129162652472045770185723510801522825687515269359046715531785342780428396"
1561       "973513311420091788963072442053377285222203558881953188370081650866793017"
1562       "948791366338993705251636497892270212003524508209121908744820211960149463"
1563       "721109340307985507678283651836204093399373959982767701148986816406250000"
1564       "000000");
1565 #endif
1566 
1567   written = LIBC_NAMESPACE::sprintf(buff, "%.500Lf", -4327677766926336.0L);
1568   ASSERT_STREQ_LEN(
1569       written, buff,
1570       "-4327677766926336."
1571       "000000000000000000000000000000000000000000000000000000000000000000000000"
1572       "000000000000000000000000000000000000000000000000000000000000000000000000"
1573       "000000000000000000000000000000000000000000000000000000000000000000000000"
1574       "000000000000000000000000000000000000000000000000000000000000000000000000"
1575       "000000000000000000000000000000000000000000000000000000000000000000000000"
1576       "000000000000000000000000000000000000000000000000000000000000000000000000"
1577       "00000000000000000000000000000000000000000000000000000000000000000000");
1578 
1579   char big_buff[10000]; // Used for extremely wide numbers.
1580 
1581 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1582   written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e1000L);
1583   ASSERT_STREQ_LEN(
1584       written, big_buff,
1585       "999999999999999999973107317669562353428234857594552594925899449376328728"
1586       "202461036775511405481186963193066642191664822065529414252060696836533522"
1587       "387143501724276282079456797058697369889056407118642873669166717313763499"
1588       "277025985141177344925615052465165938514140943010597323750202561187880136"
1589       "174810574553749194614479541820148407958204853833697063267336294787191005"
1590       "628217462261955103745349844675732989944229689277833828743730290177882029"
1591       "042613704915899149603539993716885598351951895974316347947147507970269673"
1592       "097709017164643598452451201499004104341931127294141495501309305995449742"
1593       "273419524803597130450457553871345958049837885085168840317195672271085085"
1594       "950520957945970913451088104971436093671776829538796532762184174216651692"
1595       "640931965387852083906784898823494867055070322768919156031682291829761007"
1596       "101483799978382119231551218582499361996919560548090784230386907125151658"
1597       "086767207295524036170321059257942621398084478974000973622199163292708506"
1598       "2431457550909271560663602154947063707982236377366647567795879936."
1599       "000000");
1600 
1601   written = LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 1e4900L);
1602   ASSERT_STREQ_LEN(
1603       written, big_buff,
1604       "100000000000000000002708312230690349833224052504078834346502930111959028"
1605       "517260692666637048230414374897655201843766090626319971729765251179632020"
1606       "313912652522792711197087872698264530532442630109549129842736280196919130"
1607       "242615101228133188193853826983121366159061148351354364472807590931218045"
1608       "387490935930967150336231085015126034696883068553581691802388371635128003"
1609       "615577299166097675723780877126495909902479233742826339471026068806070433"
1610       "075629449530819183550315434973800271862658869400009022028602967197463980"
1611       "126881829804282202449930132940824361207087494829502385835258094836304011"
1612       "876250359661206802659650567866176246063987902366800491980400341950657151"
1613       "370854446585517805253310195469184699955519312761482572080479702840420595"
1614       "377369017651259376039167277822106875560385309101650382998482652792335482"
1615       "865443482342801545877390859444282105890147577937366066315975231014810320"
1616       "888482059656248277607763361589359794524314002443575149260630989130103550"
1617       "443177966380769341050735632338583912575890190136462629316287947355057647"
1618       "111088565611192544631519843618778618820046304429723908484879583579178075"
1619       "456701368334212923379389029311286386996015804122917416008806233549005183"
1620       "152461084266176543129004016414959261473645240454289630182591200574019087"
1621       "358223489767381636349719510715487188747217311279465814538495924567014916"
1622       "238565628036285599497236493491668884212847699052761266207598941300449276"
1623       "447201387520841811835583254242213093566548778954711633721122784159793843"
1624       "766802019309395771984693609426401362800013936338891483689127845928572536"
1625       "790651156184721483511507878883282891696900630100211914227950790472211403"
1626       "392549466062537498185758854079775888444518306635752468713312357556380082"
1627       "275500658967283696421824354930077523691855699312544373220921962817907078"
1628       "445538421941800259027487429330768616490865438859612697367766323925013940"
1629       "918384858952407145253573823848733994146335416209309233074165707437420756"
1630       "438833918763109580759409985573826485055208965115587885226774453455112406"
1631       "581351429640282227888764449360534584421929291565334894907337572527922691"
1632       "473242328379737396430908523008687037407295838014450772162091496534584696"
1633       "605157436893236842602956298545594095307060870397506421786236892553632163"
1634       "491468601982681381011940409602294892199042638682530687578982576819839451"
1635       "907594697546439533559153604700750696252355362322662219852740143212566818"
1636       "745528402265116534684566273868361460640280523251242059850044328669692159"
1637       "629900374576027104298177006629276014371540945261309319363704125592775129"
1638       "543526908667388673739382491147471395192495459318806593271282662311169392"
1639       "196897003517840025298267505925987901751541005546610016067658227181318892"
1640       "914686508281007582655667597441346214499847364272258631922040641860333431"
1641       "409838623713258383681350233064164940590695888300919626215847587544298023"
1642       "636416943680102708406086295669759876682046839368574433996997648445207805"
1643       "615784339667691231286807666753972942872019850432610318031627872612657513"
1644       "588188267160616660825719678199868371370527508463011236193719286066916786"
1645       "169956541349011494927225747024994619057884118692213564790598702879596058"
1646       "672338334720925179141906809470606964896245458600635183723159228561689808"
1647       "246141482736625197373238197777325580142168245885279594913851700941789475"
1648       "252421784152262567254611571822468808675893407728003047921107885664474662"
1649       "930921581384003950729114103689170603748380178682003976896397305836815761"
1650       "717676338115866650889936516794601457549097578905329423919798362140648664"
1651       "569177147076571576101649257502509463877402424847669830852345415301684820"
1652       "395813946416649808062227494112874521812750160935760825922220707178083076"
1653       "380203450993589198835885505461509442443773367592842795410339065860781804"
1654       "024975272228687688301824830333940416256885455008512598774611538878683158"
1655       "183931461086893832255176926531299425504132104728730288984598001187854507"
1656       "900417184206801359847651992484444933900133130832052346600926424167009902"
1657       "829803553087005800387704758687923428053612864451456596148162238935900033"
1658       "917094683141205188616000211702577553792389670853917118547527592495253773"
1659       "028135298405566315903922235989614934474805789300370437580494193066066314"
1660       "056627605207631392651010580925826419831250810981343093764403877594495896"
1661       "516881097415880926429607388979497471571321217205535961262051641426436441"
1662       "668989765107456413733909427384182109285933511623871034309722437967253289"
1663       "084018145083721513211807496392673952789642893241520398827805325610653506"
1664       "029060153153064455898648607959013571280930834475689835845791849456112104"
1665       "462337569019001580859906425911782967213265389744605395555069797947978230"
1666       "708108432086217134763779632408473684293543722127232658767439906910370146"
1667       "716836295909075482355827087389127370874842532825987593970846704144140471"
1668       "956027276735614286138656432085771988513977140957180090146798065497158947"
1669       "229765733489703157617307078835099906185890777007500964162371428641176460"
1670       "739074789794941408428328217107759915202650066155868439585510978709442590"
1671       "231934194956788626761834746430104077432547436359522462253411168467463134"
1672       "24896.000000");
1673 
1674   written =
1675       LIBC_NAMESPACE::sprintf(big_buff, "%Lf", 0xf.fffffffffffffffp+16380L);
1676   ASSERT_STREQ_LEN(
1677       written, big_buff,
1678       "118973149535723176502126385303097020516906332229462420044032373389173700"
1679       "552297072261641029033652888285354569780749557731442744315367028843419812"
1680       "557385374367867359320070697326320191591828296152436552951064679108661431"
1681       "179063216977883889613478656060039914875343321145491116008867984515486651"
1682       "285234014977303760000912547939396622315138362241783854274391783813871780"
1683       "588948754057516822634765923557697480511372564902088485522249479139937758"
1684       "502601177354918009979622602685950855888360815984690023564513234659447638"
1685       "493985927645628457966177293040780660922910271504608538808795932778162298"
1686       "682754783076808004015069494230341172895777710033571401055977524212405734"
1687       "700738625166011082837911962300846927720096515350020847447079244384854591"
1688       "288672300061908512647211195136146752763351956292759795725027800298079590"
1689       "419313960302147099703527646744553092202267965628099149823208332964124103"
1690       "850923918473478612192169721054348428704835340811304257300221642134891734"
1691       "717423480071488075100206439051723424765600472176809648610799494341570347"
1692       "632064355862420744350442438056613601760883747816538902780957697597728686"
1693       "007148702828795556714140463261583262360276289631617397848425448686060994"
1694       "827086796804807870251185893083854658422304090880599629459458620190376604"
1695       "844679092600222541053077590106576067134720012584640695703025713896098375"
1696       "799892695455305236856075868317922311363951946885088077187210470520395758"
1697       "748001314313144425494391994017575316933939236688185618912993172910425292"
1698       "123683515992232205099800167710278403536014082929639811512287776813570604"
1699       "578934353545169653956125404884644716978689321167108722908808277835051822"
1700       "885764606221873970285165508372099234948333443522898475123275372663606621"
1701       "390228126470623407535207172405866507951821730346378263135339370677490195"
1702       "019784169044182473806316282858685774143258116536404021840272491339332094"
1703       "921949842244273042701987304453662035026238695780468200360144729199712309"
1704       "553005720614186697485284685618651483271597448120312194675168637934309618"
1705       "961510733006555242148519520176285859509105183947250286387163249416761380"
1706       "499631979144187025430270675849519200883791516940158174004671147787720145"
1707       "964446117520405945350476472180797576111172084627363927960033967047003761"
1708       "337450955318415007379641260504792325166135484129188421134082301547330475"
1709       "406707281876350361733290800595189632520707167390454777712968226520622565"
1710       "143991937680440029238090311243791261477625596469422198137514696707944687"
1711       "035800439250765945161837981185939204954403611491531078225107269148697980"
1712       "924094677214272701240437718740921675661363493890045123235166814608932240"
1713       "069799317601780533819184998193300841098599393876029260139091141452600372"
1714       "028487213241195542428210183120421610446740462163533690058366460659115629"
1715       "876474552506814500393294140413149540067760295100596225302282300363147382"
1716       "468105964844244132486457313743759509641616804802412935187620466813563687"
1717       "753281467553879887177183651289394719533506188500326760735438867336800207"
1718       "438784965701457609034985757124304510203873049485425670247933932280911052"
1719       "604153852899484920399109194612991249163328991799809438033787952209313146"
1720       "694614970593966415237594928589096048991612194498998638483702248667224914"
1721       "892467841020618336462741696957630763248023558797524525373703543388296086"
1722       "275342774001633343405508353704850737454481975472222897528108302089868263"
1723       "302028525992308416805453968791141829762998896457648276528750456285492426"
1724       "516521775079951625966922911497778896235667095662713848201819134832168799"
1725       "586365263762097828507009933729439678463987902491451422274252700636394232"
1726       "799848397673998715441855420156224415492665301451550468548925862027608576"
1727       "183712976335876121538256512963353814166394951655600026415918655485005705"
1728       "261143195291991880795452239464962763563017858089669222640623538289853586"
1729       "759599064700838568712381032959192649484625076899225841930548076362021508"
1730       "902214922052806984201835084058693849381549890944546197789302911357651677"
1731       "540623227829831403347327660395223160342282471752818181884430488092132193"
1732       "355086987339586127607367086665237555567580317149010847732009642431878007"
1733       "000879734603290627894355374356444885190719161645514115576193939969076741"
1734       "515640282654366402676009508752394550734155613586793306603174472092444651"
1735       "353236664764973540085196704077110364053815007348689179836404957060618953"
1736       "500508984091382686953509006678332447257871219660441528492484004185093281"
1737       "190896363417573989716659600075948780061916409485433875852065711654107226"
1738       "099628815012314437794400874930194474433078438899570184271000480830501217"
1739       "712356062289507626904285680004771889315808935851559386317665294808903126"
1740       "774702966254511086154895839508779675546413794489596052797520987481383976"
1741       "257859210575628440175934932416214833956535018919681138909184379573470326"
1742       "940634289008780584694035245347939808067427323629788710086717580253156130"
1743       "235606487870925986528841635097252953709111431720488774740553905400942537"
1744       "542411931794417513706468964386151771884986701034153254238591108962471088"
1745       "538580868883777725864856414593426212108664758848926003176234596076950884"
1746       "9149662444156604419552086811989770240.000000");
1747 #endif
1748 
1749   written = LIBC_NAMESPACE::sprintf(big_buff, "%.10Lf", 1e-10L);
1750   ASSERT_STREQ_LEN(written, big_buff, "0.0000000001");
1751 
1752 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
1753   written = LIBC_NAMESPACE::sprintf(big_buff, "%.7500Lf", 1e-4900L);
1754   ASSERT_STREQ_LEN(
1755       written, big_buff,
1756       "0."
1757       "000000000000000000000000000000000000000000000000000000000000000000000000"
1758       "000000000000000000000000000000000000000000000000000000000000000000000000"
1759       "000000000000000000000000000000000000000000000000000000000000000000000000"
1760       "000000000000000000000000000000000000000000000000000000000000000000000000"
1761       "000000000000000000000000000000000000000000000000000000000000000000000000"
1762       "000000000000000000000000000000000000000000000000000000000000000000000000"
1763       "000000000000000000000000000000000000000000000000000000000000000000000000"
1764       "000000000000000000000000000000000000000000000000000000000000000000000000"
1765       "000000000000000000000000000000000000000000000000000000000000000000000000"
1766       "000000000000000000000000000000000000000000000000000000000000000000000000"
1767       "000000000000000000000000000000000000000000000000000000000000000000000000"
1768       "000000000000000000000000000000000000000000000000000000000000000000000000"
1769       "000000000000000000000000000000000000000000000000000000000000000000000000"
1770       "000000000000000000000000000000000000000000000000000000000000000000000000"
1771       "000000000000000000000000000000000000000000000000000000000000000000000000"
1772       "000000000000000000000000000000000000000000000000000000000000000000000000"
1773       "000000000000000000000000000000000000000000000000000000000000000000000000"
1774       "000000000000000000000000000000000000000000000000000000000000000000000000"
1775       "000000000000000000000000000000000000000000000000000000000000000000000000"
1776       "000000000000000000000000000000000000000000000000000000000000000000000000"
1777       "000000000000000000000000000000000000000000000000000000000000000000000000"
1778       "000000000000000000000000000000000000000000000000000000000000000000000000"
1779       "000000000000000000000000000000000000000000000000000000000000000000000000"
1780       "000000000000000000000000000000000000000000000000000000000000000000000000"
1781       "000000000000000000000000000000000000000000000000000000000000000000000000"
1782       "000000000000000000000000000000000000000000000000000000000000000000000000"
1783       "000000000000000000000000000000000000000000000000000000000000000000000000"
1784       "000000000000000000000000000000000000000000000000000000000000000000000000"
1785       "000000000000000000000000000000000000000000000000000000000000000000000000"
1786       "000000000000000000000000000000000000000000000000000000000000000000000000"
1787       "000000000000000000000000000000000000000000000000000000000000000000000000"
1788       "000000000000000000000000000000000000000000000000000000000000000000000000"
1789       "000000000000000000000000000000000000000000000000000000000000000000000000"
1790       "000000000000000000000000000000000000000000000000000000000000000000000000"
1791       "000000000000000000000000000000000000000000000000000000000000000000000000"
1792       "000000000000000000000000000000000000000000000000000000000000000000000000"
1793       "000000000000000000000000000000000000000000000000000000000000000000000000"
1794       "000000000000000000000000000000000000000000000000000000000000000000000000"
1795       "000000000000000000000000000000000000000000000000000000000000000000000000"
1796       "000000000000000000000000000000000000000000000000000000000000000000000000"
1797       "000000000000000000000000000000000000000000000000000000000000000000000000"
1798       "000000000000000000000000000000000000000000000000000000000000000000000000"
1799       "000000000000000000000000000000000000000000000000000000000000000000000000"
1800       "000000000000000000000000000000000000000000000000000000000000000000000000"
1801       "000000000000000000000000000000000000000000000000000000000000000000000000"
1802       "000000000000000000000000000000000000000000000000000000000000000000000000"
1803       "000000000000000000000000000000000000000000000000000000000000000000000000"
1804       "000000000000000000000000000000000000000000000000000000000000000000000000"
1805       "000000000000000000000000000000000000000000000000000000000000000000000000"
1806       "000000000000000000000000000000000000000000000000000000000000000000000000"
1807       "000000000000000000000000000000000000000000000000000000000000000000000000"
1808       "000000000000000000000000000000000000000000000000000000000000000000000000"
1809       "000000000000000000000000000000000000000000000000000000000000000000000000"
1810       "000000000000000000000000000000000000000000000000000000000000000000000000"
1811       "000000000000000000000000000000000000000000000000000000000000000000000000"
1812       "000000000000000000000000000000000000000000000000000000000000000000000000"
1813       "000000000000000000000000000000000000000000000000000000000000000000000000"
1814       "000000000000000000000000000000000000000000000000000000000000000000000000"
1815       "000000000000000000000000000000000000000000000000000000000000000000000000"
1816       "000000000000000000000000000000000000000000000000000000000000000000000000"
1817       "000000000000000000000000000000000000000000000000000000000000000000000000"
1818       "000000000000000000000000000000000000000000000000000000000000000000000000"
1819       "000000000000000000000000000000000000000000000000000000000000000000000000"
1820       "000000000000000000000000000000000000000000000000000000000000000000000000"
1821       "000000000000000000000000000000000000000000000000000000000000000000000000"
1822       "000000000000000000000000000000000000000000000000000000000000000000000000"
1823       "000000000000000000000000000000000000000000000000000000000000000000000000"
1824       "000000000000000000000000000000000000000000000000000000000000000000000000"
1825       "000099999999999999999996962764452956071352139203248614920751610856665084"
1826       "549214352477698417183862158583009348897567779527408501588132175167211539"
1827       "462139941448204886585901454195352527238724272760638086779284030512649793"
1828       "039219351187928723378036480041948464946018272171365770411701020666925613"
1829       "422460317465324758217878522666789603627480490870456508256359180089236338"
1830       "765625231186929290294207420828927406735690318849109129700396907705735097"
1831       "663944722727287361650042373203763784830198232253311807069225650324196304"
1832       "532045014970637489181357566354288111205943347410488298480279857453705249"
1833       "232862728556860184412369114663536200895729846877559808001004454634804626"
1834       "541455540260282018142615835686583304903486353937549394736905011798466731"
1835       "536563240053860118551127061960208467764243724656897127545613968909523389"
1836       "577188368809623987105800147797280462974804046545425080530020901531407223"
1837       "191237123282274818236437397994019915368657474589800678444589412286037789"
1838       "891525464936023205313685584525510094270344601331453730179416773626565262"
1839       "480345858564672442896904520146956686863172737711483866766404977719744767"
1840       "834324844875237277613991088218774564658513875732403456058414595576806383"
1841       "115554713240005982141397577420073082470139244845624915873825746771661332"
1842       "098677966580506186966978746832443976821987300902957597498388211921362869"
1843       "017846215557612829071692275292036211064515305528052919611691470945774714"
1844       "135516559501572279732350629089770249554808690411603894492333360300589658"
1845       "470898965370892774715815089075170720164713889237058574941489766701880158"
1846       "060081295483989540170337129032188818293132770882381428397119039835946745"
1847       "549356649433406617266370644136291924838857814675939156677910783740103207"
1848       "523299367093130816446415259371931925208362367989095199399211644084543790"
1849       "110432339056231037520216864358899218874658268610955002763260912337688947"
1850       "822453100821038299301092582962825965939081817836419126254832772002214908"
1851       "085575905761843610944187009818156363893015929300295112598059949496854566"
1852       "638748010633726861510500653821408135845840123073754133549077708843800674"
1853       "328440913743105608636458354618912183716456158809545183074062249922212944"
1854       "249667793845728355381309084891765979111348980470647082269921872595470473"
1855       "719354467594516320911964549508538492057120740224559944452120552719041944"
1856       "961475548547884309626382512432626380881023756568143060204097921571153170"
1857       "723817845809196253498326358439807445210362177680590181657555380795450462"
1858       "223805222580359379367452693270553602179122419370586308101820559214330382"
1859       "570449525088342437216896462077260223998756027453411520977536701491759878"
1860       "422771447006016890777855573925295187921971811871399320142563330377888532"
1861       "179817332113");
1862 #endif
1863 #endif // LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80
1864 }
1865 
1866 TEST(LlvmLibcSPrintfTest, FloatExponentConv) {
1867   char buff[1000];
1868   int written;
1869 
1870   ForceRoundingMode r(RoundingMode::Nearest);
1871   double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
1872   double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
1873 
1874   written = LIBC_NAMESPACE::sprintf(buff, "%e", 1.0);
1875   ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
1876 
1877   written = LIBC_NAMESPACE::sprintf(buff, "%E", -1.0);
1878   ASSERT_STREQ_LEN(written, buff, "-1.000000E+00");
1879 
1880   written = LIBC_NAMESPACE::sprintf(buff, "%e", -1.234567);
1881   ASSERT_STREQ_LEN(written, buff, "-1.234567e+00");
1882 
1883   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.0);
1884   ASSERT_STREQ_LEN(written, buff, "0.000000e+00");
1885 
1886   written = LIBC_NAMESPACE::sprintf(buff, "%e", 1.5);
1887   ASSERT_STREQ_LEN(written, buff, "1.500000e+00");
1888 
1889   written = LIBC_NAMESPACE::sprintf(buff, "%e", 1e300);
1890   ASSERT_STREQ_LEN(written, buff, "1.000000e+300");
1891 
1892   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.1);
1893   ASSERT_STREQ_LEN(written, buff, "1.000000e-01");
1894 
1895   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.001);
1896   ASSERT_STREQ_LEN(written, buff, "1.000000e-03");
1897 
1898   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.00001);
1899   ASSERT_STREQ_LEN(written, buff, "1.000000e-05");
1900 
1901   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.0000001);
1902   ASSERT_STREQ_LEN(written, buff, "1.000000e-07");
1903 
1904   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.000000001);
1905   ASSERT_STREQ_LEN(written, buff, "1.000000e-09");
1906 
1907   written = LIBC_NAMESPACE::sprintf(buff, "%e", 1.0e-20);
1908   ASSERT_STREQ_LEN(written, buff, "1.000000e-20");
1909 
1910   written = LIBC_NAMESPACE::sprintf(buff, "%e", 1234567890123456789.0);
1911   ASSERT_STREQ_LEN(written, buff, "1.234568e+18");
1912 
1913   written = LIBC_NAMESPACE::sprintf(buff, "%e", 9999999000000.00);
1914   ASSERT_STREQ_LEN(written, buff, "9.999999e+12");
1915 
1916   // Simple Subnormal Tests.
1917 
1918   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0x1.0p-1027);
1919   ASSERT_STREQ_LEN(written, buff, "6.953356e-310");
1920 
1921   written = LIBC_NAMESPACE::sprintf(buff, "%e", 0x1.0p-1074);
1922   ASSERT_STREQ_LEN(written, buff, "4.940656e-324");
1923 
1924   // Inf/Nan Tests.
1925 
1926   written = LIBC_NAMESPACE::sprintf(buff, "%e", inf);
1927   ASSERT_STREQ_LEN(written, buff, "inf");
1928 
1929   written = LIBC_NAMESPACE::sprintf(buff, "%E", -inf);
1930   ASSERT_STREQ_LEN(written, buff, "-INF");
1931 
1932   written = LIBC_NAMESPACE::sprintf(buff, "%e", nan);
1933   ASSERT_STREQ_LEN(written, buff, "nan");
1934 
1935   written = LIBC_NAMESPACE::sprintf(buff, "%E", -nan);
1936   ASSERT_STREQ_LEN(written, buff, "-NAN");
1937 
1938   // Min Width Tests.
1939 
1940   written = LIBC_NAMESPACE::sprintf(buff, "%15e", 1.0);
1941   ASSERT_STREQ_LEN(written, buff, "   1.000000e+00");
1942 
1943   written = LIBC_NAMESPACE::sprintf(buff, "%15e", -1.0);
1944   ASSERT_STREQ_LEN(written, buff, "  -1.000000e+00");
1945 
1946   written = LIBC_NAMESPACE::sprintf(buff, "%15e", 1.0e5);
1947   ASSERT_STREQ_LEN(written, buff, "   1.000000e+05");
1948 
1949   written = LIBC_NAMESPACE::sprintf(buff, "%15e", -1.0e5);
1950   ASSERT_STREQ_LEN(written, buff, "  -1.000000e+05");
1951 
1952   written = LIBC_NAMESPACE::sprintf(buff, "%10e", 1.0e-5);
1953   ASSERT_STREQ_LEN(written, buff, "1.000000e-05");
1954 
1955   // Precision Tests.
1956 
1957   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.0);
1958   ASSERT_STREQ_LEN(written, buff, "1.0e+00");
1959 
1960   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 0.0);
1961   ASSERT_STREQ_LEN(written, buff, "0.0e+00");
1962 
1963   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 0.0);
1964   ASSERT_STREQ_LEN(written, buff, "0e+00");
1965 
1966   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 0.1);
1967   ASSERT_STREQ_LEN(written, buff, "1.0e-01");
1968 
1969   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.09);
1970   ASSERT_STREQ_LEN(written, buff, "1.1e+00");
1971 
1972   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.04);
1973   ASSERT_STREQ_LEN(written, buff, "1.0e+00");
1974 
1975   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.19);
1976   ASSERT_STREQ_LEN(written, buff, "1.2e+00");
1977 
1978   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.99);
1979   ASSERT_STREQ_LEN(written, buff, "2.0e+00");
1980 
1981   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 9.99);
1982   ASSERT_STREQ_LEN(written, buff, "1.0e+01");
1983 
1984   written = LIBC_NAMESPACE::sprintf(buff, "%.2e", 99.9);
1985   ASSERT_STREQ_LEN(written, buff, "9.99e+01");
1986 
1987   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 99.9);
1988   ASSERT_STREQ_LEN(written, buff, "1.0e+02");
1989 
1990   written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 1.25);
1991   ASSERT_STREQ_LEN(written, buff, "1.25000e+00");
1992 
1993   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 1.25);
1994   ASSERT_STREQ_LEN(written, buff, "1e+00");
1995 
1996   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 1.75);
1997   ASSERT_STREQ_LEN(written, buff, "2e+00");
1998 
1999   written = LIBC_NAMESPACE::sprintf(buff, "%.20e", 1.234e-10);
2000   ASSERT_STREQ_LEN(written, buff, "1.23400000000000008140e-10");
2001 
2002   written = LIBC_NAMESPACE::sprintf(buff, "%.2e", -9.99);
2003   ASSERT_STREQ_LEN(written, buff, "-9.99e+00");
2004 
2005   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -9.99);
2006   ASSERT_STREQ_LEN(written, buff, "-1.0e+01");
2007 
2008   written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 0.0);
2009   ASSERT_STREQ_LEN(written, buff, "0.00000e+00");
2010 
2011   written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 1.008);
2012   ASSERT_STREQ_LEN(written, buff, "1.00800e+00");
2013 
2014   written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 1.008e3);
2015   ASSERT_STREQ_LEN(written, buff, "1.00800e+03");
2016 
2017   // These tests also focus on rounding. Almost all of them have a 5 right after
2018   // the printed string (e.g. 9.5 with precision 0 prints 0 digits after the
2019   // decimal point). This is again because rounding a number with a 5 after the
2020   // printed section means that more digits have to be checked to determine if
2021   // this should be rounded up (if there are non-zero digits after the 5) or to
2022   // even (if the 5 is the last non-zero digit). Additionally, the algorithm for
2023   // checking if a number is all 0s after the decimal point may not work since
2024   // the decimal point moves in this representation.
2025   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 2.5812229360061737E+200);
2026   ASSERT_STREQ_LEN(written, buff, "3e+200");
2027 
2028   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 9.059E+200);
2029   ASSERT_STREQ_LEN(written, buff, "9.1e+200");
2030 
2031   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 9.059E+200);
2032   ASSERT_STREQ_LEN(written, buff, "9e+200");
2033 
2034 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2035   written = LIBC_NAMESPACE::sprintf(buff, "%.166e", 1.131959884853339E-72);
2036   ASSERT_STREQ_LEN(written, buff,
2037                    "1."
2038                    "13195988485333904593863991136097397258531639976739227369782"
2039                    "68612419376648241056393424414314951197624317440549121097287"
2040                    "069853416091591569170304865110665559768676757812e-72");
2041 #endif
2042 
2043   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 9.5);
2044   ASSERT_STREQ_LEN(written, buff, "1e+01");
2045 
2046   written = LIBC_NAMESPACE::sprintf(buff, "%.10e", 1.9999999999890936);
2047   ASSERT_STREQ_LEN(written, buff, "2.0000000000e+00");
2048 
2049   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 745362143563.03894);
2050   ASSERT_STREQ_LEN(written, buff, "7.5e+11");
2051 
2052   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 45181042688.0);
2053   ASSERT_STREQ_LEN(written, buff, "5e+10");
2054 
2055   written = LIBC_NAMESPACE::sprintf(buff, "%.35e", 1.3752441369139243);
2056   ASSERT_STREQ_LEN(written, buff, "1.37524413691392433101157166674965993e+00");
2057 
2058   // Subnormal Precision Tests
2059 
2060 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2061   written = LIBC_NAMESPACE::sprintf(buff, "%.310e", 0x1.0p-1022);
2062   ASSERT_STREQ_LEN(
2063       written, buff,
2064       "2."
2065       "225073858507201383090232717332404064219215980462331830553327416887204434"
2066       "813918195854283159012511020564067339731035811005152434161553460108856012"
2067       "385377718821130777993532002330479610147442583636071921565046942503734208"
2068       "375250806650616658158948720491179968591639648500635908770118304874799780"
2069       "8877537499494515804516e-308");
2070 #endif
2071 
2072   written = LIBC_NAMESPACE::sprintf(buff, "%.30e", 0x1.0p-1022);
2073   ASSERT_STREQ_LEN(written, buff, "2.225073858507201383090232717332e-308");
2074 
2075 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2076   written = LIBC_NAMESPACE::sprintf(buff, "%.310e", 0x1.0p-1023);
2077   ASSERT_STREQ_LEN(
2078       written, buff,
2079       "1."
2080       "112536929253600691545116358666202032109607990231165915276663708443602217"
2081       "406959097927141579506255510282033669865517905502576217080776730054428006"
2082       "192688859410565388996766001165239805073721291818035960782523471251867104"
2083       "187625403325308329079474360245589984295819824250317954385059152437399890"
2084       "4438768749747257902258e-308");
2085 #endif
2086 
2087   written = LIBC_NAMESPACE::sprintf(buff, "%.6e", 9.99999e-310);
2088   ASSERT_STREQ_LEN(written, buff, "9.999990e-310");
2089 
2090   written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 9.99999e-310);
2091   ASSERT_STREQ_LEN(written, buff, "9.99999e-310");
2092 
2093   written = LIBC_NAMESPACE::sprintf(buff, "%.4e", 9.99999e-310);
2094   ASSERT_STREQ_LEN(written, buff, "1.0000e-309");
2095 
2096   written = LIBC_NAMESPACE::sprintf(buff, "%.3e", 9.99999e-310);
2097   ASSERT_STREQ_LEN(written, buff, "1.000e-309");
2098 
2099   written = LIBC_NAMESPACE::sprintf(buff, "%.2e", 9.99999e-310);
2100   ASSERT_STREQ_LEN(written, buff, "1.00e-309");
2101 
2102   written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 9.99999e-310);
2103   ASSERT_STREQ_LEN(written, buff, "1.0e-309");
2104 
2105   written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 9.99999e-310);
2106   ASSERT_STREQ_LEN(written, buff, "1e-309");
2107 
2108   written = LIBC_NAMESPACE::sprintf(buff, "%.10e", 0x1.0p-1074);
2109   ASSERT_STREQ_LEN(written, buff, "4.9406564584e-324");
2110 
2111   // Rounding Mode Tests.
2112 
2113   if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
2114     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2115     ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2116 
2117     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2118     ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2119 
2120     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2121     ASSERT_STREQ_LEN(written, buff, "1.1e+00");
2122 
2123     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2124     ASSERT_STREQ_LEN(written, buff, "1.6e+00");
2125 
2126     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2127     ASSERT_STREQ_LEN(written, buff, "1.4e+00");
2128 
2129     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2130     ASSERT_STREQ_LEN(written, buff, "1.9e+00");
2131 
2132     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2133     ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2134 
2135     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2136     ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2137 
2138     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2139     ASSERT_STREQ_LEN(written, buff, "-1.1e+00");
2140 
2141     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2142     ASSERT_STREQ_LEN(written, buff, "-1.6e+00");
2143 
2144     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2145     ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
2146 
2147     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2148     ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
2149   }
2150 
2151   if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
2152     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2153     ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2154 
2155     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2156     ASSERT_STREQ_LEN(written, buff, "1.3e+00");
2157 
2158     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2159     ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2160 
2161     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2162     ASSERT_STREQ_LEN(written, buff, "1.7e+00");
2163 
2164     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2165     ASSERT_STREQ_LEN(written, buff, "1.4e+00");
2166 
2167     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2168     ASSERT_STREQ_LEN(written, buff, "1.9e+00");
2169 
2170     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2171     ASSERT_STREQ_LEN(written, buff, "-1.7e+00");
2172 
2173     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2174     ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2175 
2176     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2177     ASSERT_STREQ_LEN(written, buff, "-1.1e+00");
2178 
2179     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2180     ASSERT_STREQ_LEN(written, buff, "-1.6e+00");
2181 
2182     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2183     ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
2184 
2185     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2186     ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2187   }
2188 
2189   if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
2190     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2191     ASSERT_STREQ_LEN(written, buff, "1.7e+00");
2192 
2193     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2194     ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2195 
2196     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2197     ASSERT_STREQ_LEN(written, buff, "1.1e+00");
2198 
2199     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2200     ASSERT_STREQ_LEN(written, buff, "1.6e+00");
2201 
2202     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2203     ASSERT_STREQ_LEN(written, buff, "1.3e+00");
2204 
2205     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2206     ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2207 
2208     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2209     ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2210 
2211     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2212     ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
2213 
2214     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2215     ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2216 
2217     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2218     ASSERT_STREQ_LEN(written, buff, "-1.7e+00");
2219 
2220     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2221     ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
2222 
2223     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2224     ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
2225   }
2226 
2227   if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
2228     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2229     ASSERT_STREQ_LEN(written, buff, "1.7e+00");
2230 
2231     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2232     ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2233 
2234     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2235     ASSERT_STREQ_LEN(written, buff, "1.1e+00");
2236 
2237     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2238     ASSERT_STREQ_LEN(written, buff, "1.6e+00");
2239 
2240     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2241     ASSERT_STREQ_LEN(written, buff, "1.3e+00");
2242 
2243     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2244     ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2245 
2246     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2247     ASSERT_STREQ_LEN(written, buff, "-1.7e+00");
2248 
2249     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2250     ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2251 
2252     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2253     ASSERT_STREQ_LEN(written, buff, "-1.1e+00");
2254 
2255     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2256     ASSERT_STREQ_LEN(written, buff, "-1.6e+00");
2257 
2258     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2259     ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
2260 
2261     written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2262     ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2263   }
2264 
2265   // Flag Tests.
2266   written = LIBC_NAMESPACE::sprintf(buff, "%+e", 1.0);
2267   ASSERT_STREQ_LEN(written, buff, "+1.000000e+00");
2268 
2269   written = LIBC_NAMESPACE::sprintf(buff, "%+e", -1.0);
2270   ASSERT_STREQ_LEN(written, buff, "-1.000000e+00");
2271 
2272   written = LIBC_NAMESPACE::sprintf(buff, "% e", 1.0);
2273   ASSERT_STREQ_LEN(written, buff, " 1.000000e+00");
2274 
2275   written = LIBC_NAMESPACE::sprintf(buff, "% e", -1.0);
2276   ASSERT_STREQ_LEN(written, buff, "-1.000000e+00");
2277 
2278   written = LIBC_NAMESPACE::sprintf(buff, "%-15e", 1.5);
2279   ASSERT_STREQ_LEN(written, buff, "1.500000e+00   ");
2280 
2281   written = LIBC_NAMESPACE::sprintf(buff, "%#.e", 1.0);
2282   ASSERT_STREQ_LEN(written, buff, "1.e+00");
2283 
2284   written = LIBC_NAMESPACE::sprintf(buff, "%#.0e", 1.5);
2285   ASSERT_STREQ_LEN(written, buff, "2.e+00");
2286 
2287   written = LIBC_NAMESPACE::sprintf(buff, "%015e", 1.5);
2288   ASSERT_STREQ_LEN(written, buff, "0001.500000e+00");
2289 
2290   written = LIBC_NAMESPACE::sprintf(buff, "%015e", -1.5);
2291   ASSERT_STREQ_LEN(written, buff, "-001.500000e+00");
2292 
2293   written = LIBC_NAMESPACE::sprintf(buff, "%+- #0e", 0.0);
2294   ASSERT_STREQ_LEN(written, buff, "+0.000000e+00");
2295 
2296   // Combined Tests.
2297 
2298   written = LIBC_NAMESPACE::sprintf(buff, "%10.2e", 9.99);
2299   ASSERT_STREQ_LEN(written, buff, "  9.99e+00");
2300 
2301   written = LIBC_NAMESPACE::sprintf(buff, "%10.1e", 9.99);
2302   ASSERT_STREQ_LEN(written, buff, "   1.0e+01");
2303 
2304   written = LIBC_NAMESPACE::sprintf(buff, "%10.0e", 9.99);
2305   ASSERT_STREQ_LEN(written, buff, "     1e+01");
2306 
2307   written = LIBC_NAMESPACE::sprintf(buff, "%10.0e", 0.0999);
2308   ASSERT_STREQ_LEN(written, buff, "     1e-01");
2309 
2310   written = LIBC_NAMESPACE::sprintf(buff, "%-10.2e", 9.99);
2311   ASSERT_STREQ_LEN(written, buff, "9.99e+00  ");
2312 
2313   written = LIBC_NAMESPACE::sprintf(buff, "%-10.1e", 9.99);
2314   ASSERT_STREQ_LEN(written, buff, "1.0e+01   ");
2315 
2316   written = LIBC_NAMESPACE::sprintf(buff, "%-10.1e", 1.0e-50);
2317   ASSERT_STREQ_LEN(written, buff, "1.0e-50   ");
2318 
2319   written = LIBC_NAMESPACE::sprintf(buff, "%30e", 1234567890123456789.0);
2320   ASSERT_STREQ_LEN(written, buff, "                  1.234568e+18");
2321 
2322   written = LIBC_NAMESPACE::sprintf(buff, "%-30e", 1234567890123456789.0);
2323   ASSERT_STREQ_LEN(written, buff, "1.234568e+18                  ");
2324 
2325   written = LIBC_NAMESPACE::sprintf(buff, "%25.14e", 9999999999999.99);
2326   ASSERT_STREQ_LEN(written, buff, "     9.99999999999999e+12");
2327 
2328   written = LIBC_NAMESPACE::sprintf(buff, "%25.13e", 9999999999999.99);
2329   ASSERT_STREQ_LEN(written, buff, "      1.0000000000000e+13");
2330 
2331   written = LIBC_NAMESPACE::sprintf(buff, "%25.12e", 9999999999999.99);
2332   ASSERT_STREQ_LEN(written, buff, "       1.000000000000e+13");
2333 
2334   written = LIBC_NAMESPACE::sprintf(buff, "%12.3e %-12.3e", 0.1, 256.0);
2335   ASSERT_STREQ_LEN(written, buff, "   1.000e-01 2.560e+02   ");
2336 
2337   written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3e % 012.3e", 0.1256, 1256.0);
2338   ASSERT_STREQ_LEN(written, buff, "+1.256e-01    001.256e+03");
2339 }
2340 
2341 TEST(LlvmLibcSPrintfTest, FloatExponentLongDoubleConv) {
2342   char buff[1000];
2343   int written;
2344 
2345   ForceRoundingMode r(RoundingMode::Nearest);
2346   // Length Modifier Tests.
2347 
2348   written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.1L);
2349   ASSERT_STREQ_LEN(written, buff, "1.000000001e+18");
2350 
2351   written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.0L);
2352   ASSERT_STREQ_LEN(written, buff, "1.000000000e+18");
2353 
2354   written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1e100L);
2355   ASSERT_STREQ_LEN(written, buff, "1.000000e+100");
2356 
2357   written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1.0L);
2358   ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
2359 
2360 #if !defined(LIBC_TYPES_LONG_DOUBLE_IS_DOUBLE)
2361   written = LIBC_NAMESPACE::sprintf(buff, "%Le", 0xf.fffffffffffffffp+16380L);
2362   ASSERT_STREQ_LEN(written, buff, "1.189731e+4932");
2363 
2364   written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1e1000L);
2365   ASSERT_STREQ_LEN(written, buff, "1.000000e+1000");
2366 
2367   written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1e4900L);
2368   ASSERT_STREQ_LEN(written, buff, "1.000000e+4900");
2369 
2370   written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1.2345678e4900L);
2371   ASSERT_STREQ_LEN(written, buff, "1.234568e+4900");
2372 #endif
2373 }
2374 
2375 TEST(LlvmLibcSPrintfTest, FloatAutoConv) {
2376   char buff[1000];
2377   int written;
2378 
2379   ForceRoundingMode r(RoundingMode::Nearest);
2380   double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
2381   double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
2382 
2383   written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0);
2384   ASSERT_STREQ_LEN(written, buff, "1");
2385 
2386   written = LIBC_NAMESPACE::sprintf(buff, "%G", -1.0);
2387   ASSERT_STREQ_LEN(written, buff, "-1");
2388 
2389   written = LIBC_NAMESPACE::sprintf(buff, "%g", -1.234567);
2390   ASSERT_STREQ_LEN(written, buff, "-1.23457");
2391 
2392   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0);
2393   ASSERT_STREQ_LEN(written, buff, "0");
2394 
2395   written = LIBC_NAMESPACE::sprintf(buff, "%g", -0.0);
2396   ASSERT_STREQ_LEN(written, buff, "-0");
2397 
2398   written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.5);
2399   ASSERT_STREQ_LEN(written, buff, "1.5");
2400 
2401   written = LIBC_NAMESPACE::sprintf(buff, "%g", 1e300);
2402   ASSERT_STREQ_LEN(written, buff, "1e+300");
2403 
2404   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.1);
2405   ASSERT_STREQ_LEN(written, buff, "0.1");
2406 
2407   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.001);
2408   ASSERT_STREQ_LEN(written, buff, "0.001");
2409 
2410   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.00001);
2411   ASSERT_STREQ_LEN(written, buff, "1e-05");
2412 
2413   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0000001);
2414   ASSERT_STREQ_LEN(written, buff, "1e-07");
2415 
2416   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.000000001);
2417   ASSERT_STREQ_LEN(written, buff, "1e-09");
2418 
2419   written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0e-20);
2420   ASSERT_STREQ_LEN(written, buff, "1e-20");
2421 
2422   written = LIBC_NAMESPACE::sprintf(buff, "%g", 1234567890123456789.0);
2423   ASSERT_STREQ_LEN(written, buff, "1.23457e+18");
2424 
2425   written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999990000000.00);
2426   ASSERT_STREQ_LEN(written, buff, "9.99999e+12");
2427 
2428   written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999999000000.00);
2429   ASSERT_STREQ_LEN(written, buff, "1e+13");
2430 
2431   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0xa.aaaaaaaaaaaaaabp-7);
2432   ASSERT_STREQ_LEN(written, buff, "0.0833333");
2433 
2434   // Simple Subnormal Tests.
2435 
2436   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1027);
2437   ASSERT_STREQ_LEN(written, buff, "6.95336e-310");
2438 
2439   written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1074);
2440   ASSERT_STREQ_LEN(written, buff, "4.94066e-324");
2441 
2442   // Inf/Nan Tests.
2443 
2444   written = LIBC_NAMESPACE::sprintf(buff, "%g", inf);
2445   ASSERT_STREQ_LEN(written, buff, "inf");
2446 
2447   written = LIBC_NAMESPACE::sprintf(buff, "%G", -inf);
2448   ASSERT_STREQ_LEN(written, buff, "-INF");
2449 
2450   written = LIBC_NAMESPACE::sprintf(buff, "%g", nan);
2451   ASSERT_STREQ_LEN(written, buff, "nan");
2452 
2453   written = LIBC_NAMESPACE::sprintf(buff, "%G", -nan);
2454   ASSERT_STREQ_LEN(written, buff, "-NAN");
2455 
2456   // Min Width Tests.
2457 
2458   written = LIBC_NAMESPACE::sprintf(buff, "%15g", 1.0);
2459   ASSERT_STREQ_LEN(written, buff, "              1");
2460 
2461   written = LIBC_NAMESPACE::sprintf(buff, "%15g", -1.0);
2462   ASSERT_STREQ_LEN(written, buff, "             -1");
2463 
2464   written = LIBC_NAMESPACE::sprintf(buff, "%15g", 1.0e5);
2465   ASSERT_STREQ_LEN(written, buff, "         100000");
2466 
2467   written = LIBC_NAMESPACE::sprintf(buff, "%15g", -1.0e5);
2468   ASSERT_STREQ_LEN(written, buff, "        -100000");
2469 
2470   written = LIBC_NAMESPACE::sprintf(buff, "%10g", 1.0e-5);
2471   ASSERT_STREQ_LEN(written, buff, "     1e-05");
2472 
2473   // Precision Tests.
2474 
2475   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.23456789);
2476   ASSERT_STREQ_LEN(written, buff, "1.2");
2477 
2478   // Trimming trailing zeroes causes the precision to be ignored here.
2479   written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 0.0);
2480   ASSERT_STREQ_LEN(written, buff, "0");
2481 
2482   written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 0.0);
2483   ASSERT_STREQ_LEN(written, buff, "0");
2484 
2485   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 0.1);
2486   ASSERT_STREQ_LEN(written, buff, "0.1");
2487 
2488   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.09);
2489   ASSERT_STREQ_LEN(written, buff, "1.1");
2490 
2491   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.04);
2492   ASSERT_STREQ_LEN(written, buff, "1");
2493 
2494   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.19);
2495   ASSERT_STREQ_LEN(written, buff, "1.2");
2496 
2497   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.99);
2498   ASSERT_STREQ_LEN(written, buff, "2");
2499 
2500   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 9.99);
2501   ASSERT_STREQ_LEN(written, buff, "10");
2502 
2503   written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 99.9);
2504   ASSERT_STREQ_LEN(written, buff, "99.9");
2505 
2506   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 99.9);
2507   ASSERT_STREQ_LEN(written, buff, "1e+02");
2508 
2509   written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 99.9);
2510   ASSERT_STREQ_LEN(written, buff, "1e+02");
2511 
2512   written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 1.25);
2513   ASSERT_STREQ_LEN(written, buff, "1.25");
2514 
2515   written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 1.25);
2516   ASSERT_STREQ_LEN(written, buff, "1");
2517 
2518   written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 1.75);
2519   ASSERT_STREQ_LEN(written, buff, "2");
2520 
2521   written = LIBC_NAMESPACE::sprintf(buff, "%.20g", 1.234e-10);
2522   ASSERT_STREQ_LEN(written, buff, "1.2340000000000000814e-10");
2523 
2524   written = LIBC_NAMESPACE::sprintf(buff, "%.3g", -9.99);
2525   ASSERT_STREQ_LEN(written, buff, "-9.99");
2526 
2527   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -9.99);
2528   ASSERT_STREQ_LEN(written, buff, "-10");
2529 
2530   written = LIBC_NAMESPACE::sprintf(buff, "%.1g", -9.99);
2531   ASSERT_STREQ_LEN(written, buff, "-1e+01");
2532 
2533   written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 1.008);
2534   ASSERT_STREQ_LEN(written, buff, "1.008");
2535 
2536   written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 1.008e3);
2537   ASSERT_STREQ_LEN(written, buff, "1008");
2538 
2539   written = LIBC_NAMESPACE::sprintf(buff, "%.4g", 9999.0);
2540   ASSERT_STREQ_LEN(written, buff, "9999");
2541 
2542   written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 9999.0);
2543   ASSERT_STREQ_LEN(written, buff, "1e+04");
2544 
2545   written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 1256.0);
2546   ASSERT_STREQ_LEN(written, buff, "1.26e+03");
2547 
2548   // Found through large scale testing.
2549   written = LIBC_NAMESPACE::sprintf(buff, "%.15g", 22.25);
2550   ASSERT_STREQ_LEN(written, buff, "22.25");
2551 
2552   // These tests also focus on rounding, but only in how it relates to the base
2553   // 10 exponent. The %g conversion selects between being a %f or %e conversion
2554   // based on what the exponent would be if it was %e. If we call the precision
2555   // P (equal to 6 if the precision is not set, 0 if the provided precision is
2556   // 0, and provided precision - 1 otherwise) and the exponent X, then the style
2557   // is %f with an effective precision of P - X + 1 if P > X >= -4, else the
2558   // style is %e with effective precision P - 1. Additionally, it attempts to
2559   // trim zeros that would be displayed after the decimal point.
2560   written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 9.059E+200);
2561   ASSERT_STREQ_LEN(written, buff, "9e+200");
2562 
2563   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 9.059E+200);
2564   ASSERT_STREQ_LEN(written, buff, "9.1e+200");
2565 
2566   // For this test, P = 0 and X = 1, so P > X >= -4 is false, giving a %e style.
2567   written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 9.5);
2568   ASSERT_STREQ_LEN(written, buff, "1e+01");
2569 
2570   // Subnormal Precision Tests
2571 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2572   written = LIBC_NAMESPACE::sprintf(buff, "%.310g", 0x1.0p-1022);
2573   ASSERT_STREQ_LEN(
2574       written, buff,
2575       "2."
2576       "225073858507201383090232717332404064219215980462331830553327416887204434"
2577       "813918195854283159012511020564067339731035811005152434161553460108856012"
2578       "385377718821130777993532002330479610147442583636071921565046942503734208"
2579       "375250806650616658158948720491179968591639648500635908770118304874799780"
2580       "887753749949451580452e-308");
2581 #endif
2582 
2583   written = LIBC_NAMESPACE::sprintf(buff, "%.30g", 0x1.0p-1022);
2584   ASSERT_STREQ_LEN(written, buff, "2.22507385850720138309023271733e-308");
2585 
2586 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2587   written = LIBC_NAMESPACE::sprintf(buff, "%.310g", 0x1.0p-1023);
2588   ASSERT_STREQ_LEN(
2589       written, buff,
2590       "1."
2591       "112536929253600691545116358666202032109607990231165915276663708443602217"
2592       "406959097927141579506255510282033669865517905502576217080776730054428006"
2593       "192688859410565388996766001165239805073721291818035960782523471251867104"
2594       "187625403325308329079474360245589984295819824250317954385059152437399890"
2595       "443876874974725790226e-308");
2596 #endif
2597 
2598   written = LIBC_NAMESPACE::sprintf(buff, "%.7g", 9.99999e-310);
2599   ASSERT_STREQ_LEN(written, buff, "9.99999e-310");
2600 
2601   written = LIBC_NAMESPACE::sprintf(buff, "%.6g", 9.99999e-310);
2602   ASSERT_STREQ_LEN(written, buff, "9.99999e-310");
2603 
2604   written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 9.99999e-310);
2605   ASSERT_STREQ_LEN(written, buff, "1e-309");
2606 
2607   written = LIBC_NAMESPACE::sprintf(buff, "%.4g", 9.99999e-310);
2608   ASSERT_STREQ_LEN(written, buff, "1e-309");
2609 
2610   written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 9.99999e-310);
2611   ASSERT_STREQ_LEN(written, buff, "1e-309");
2612 
2613   written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 9.99999e-310);
2614   ASSERT_STREQ_LEN(written, buff, "1e-309");
2615 
2616   written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 9.99999e-310);
2617   ASSERT_STREQ_LEN(written, buff, "1e-309");
2618 
2619   written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 9.99999e-310);
2620   ASSERT_STREQ_LEN(written, buff, "1e-309");
2621 
2622   written = LIBC_NAMESPACE::sprintf(buff, "%.10g", 0x1.0p-1074);
2623   ASSERT_STREQ_LEN(written, buff, "4.940656458e-324");
2624 
2625   // Rounding Mode Tests.
2626 
2627   if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
2628     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2629     ASSERT_STREQ_LEN(written, buff, "1.8");
2630 
2631     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2632     ASSERT_STREQ_LEN(written, buff, "1.2");
2633 
2634     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2635     ASSERT_STREQ_LEN(written, buff, "1.1");
2636 
2637     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2638     ASSERT_STREQ_LEN(written, buff, "1.6");
2639 
2640     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2641     ASSERT_STREQ_LEN(written, buff, "1.4");
2642 
2643     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2644     ASSERT_STREQ_LEN(written, buff, "1.9");
2645 
2646     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2647     ASSERT_STREQ_LEN(written, buff, "-1.8");
2648 
2649     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2650     ASSERT_STREQ_LEN(written, buff, "-1.2");
2651 
2652     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2653     ASSERT_STREQ_LEN(written, buff, "-1.1");
2654 
2655     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2656     ASSERT_STREQ_LEN(written, buff, "-1.6");
2657 
2658     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2659     ASSERT_STREQ_LEN(written, buff, "-1.4");
2660 
2661     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2662     ASSERT_STREQ_LEN(written, buff, "-1.9");
2663   }
2664 
2665   if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
2666     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2667     ASSERT_STREQ_LEN(written, buff, "1.8");
2668 
2669     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2670     ASSERT_STREQ_LEN(written, buff, "1.3");
2671 
2672     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2673     ASSERT_STREQ_LEN(written, buff, "1.2");
2674 
2675     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2676     ASSERT_STREQ_LEN(written, buff, "1.7");
2677 
2678     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2679     ASSERT_STREQ_LEN(written, buff, "1.4");
2680 
2681     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2682     ASSERT_STREQ_LEN(written, buff, "1.9");
2683 
2684     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2685     ASSERT_STREQ_LEN(written, buff, "-1.7");
2686 
2687     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2688     ASSERT_STREQ_LEN(written, buff, "-1.2");
2689 
2690     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2691     ASSERT_STREQ_LEN(written, buff, "-1.1");
2692 
2693     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2694     ASSERT_STREQ_LEN(written, buff, "-1.6");
2695 
2696     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2697     ASSERT_STREQ_LEN(written, buff, "-1.3");
2698 
2699     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2700     ASSERT_STREQ_LEN(written, buff, "-1.8");
2701   }
2702 
2703   if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
2704     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2705     ASSERT_STREQ_LEN(written, buff, "1.7");
2706 
2707     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2708     ASSERT_STREQ_LEN(written, buff, "1.2");
2709 
2710     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2711     ASSERT_STREQ_LEN(written, buff, "1.1");
2712 
2713     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2714     ASSERT_STREQ_LEN(written, buff, "1.6");
2715 
2716     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2717     ASSERT_STREQ_LEN(written, buff, "1.3");
2718 
2719     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2720     ASSERT_STREQ_LEN(written, buff, "1.8");
2721 
2722     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2723     ASSERT_STREQ_LEN(written, buff, "-1.8");
2724 
2725     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2726     ASSERT_STREQ_LEN(written, buff, "-1.3");
2727 
2728     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2729     ASSERT_STREQ_LEN(written, buff, "-1.2");
2730 
2731     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2732     ASSERT_STREQ_LEN(written, buff, "-1.7");
2733 
2734     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2735     ASSERT_STREQ_LEN(written, buff, "-1.4");
2736 
2737     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2738     ASSERT_STREQ_LEN(written, buff, "-1.9");
2739   }
2740 
2741   if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
2742     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2743     ASSERT_STREQ_LEN(written, buff, "1.7");
2744 
2745     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2746     ASSERT_STREQ_LEN(written, buff, "1.2");
2747 
2748     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2749     ASSERT_STREQ_LEN(written, buff, "1.1");
2750 
2751     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2752     ASSERT_STREQ_LEN(written, buff, "1.6");
2753 
2754     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2755     ASSERT_STREQ_LEN(written, buff, "1.3");
2756 
2757     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2758     ASSERT_STREQ_LEN(written, buff, "1.8");
2759 
2760     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2761     ASSERT_STREQ_LEN(written, buff, "-1.7");
2762 
2763     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2764     ASSERT_STREQ_LEN(written, buff, "-1.2");
2765 
2766     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2767     ASSERT_STREQ_LEN(written, buff, "-1.1");
2768 
2769     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2770     ASSERT_STREQ_LEN(written, buff, "-1.6");
2771 
2772     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2773     ASSERT_STREQ_LEN(written, buff, "-1.3");
2774 
2775     written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2776     ASSERT_STREQ_LEN(written, buff, "-1.8");
2777   }
2778 
2779   // Flag Tests.
2780   written = LIBC_NAMESPACE::sprintf(buff, "%+g", 1.0);
2781   ASSERT_STREQ_LEN(written, buff, "+1");
2782 
2783   written = LIBC_NAMESPACE::sprintf(buff, "%+g", -1.0);
2784   ASSERT_STREQ_LEN(written, buff, "-1");
2785 
2786   written = LIBC_NAMESPACE::sprintf(buff, "% g", 1.0);
2787   ASSERT_STREQ_LEN(written, buff, " 1");
2788 
2789   written = LIBC_NAMESPACE::sprintf(buff, "% g", -1.0);
2790   ASSERT_STREQ_LEN(written, buff, "-1");
2791 
2792   written = LIBC_NAMESPACE::sprintf(buff, "%-15g", 1.5);
2793   ASSERT_STREQ_LEN(written, buff, "1.5            ");
2794 
2795   written = LIBC_NAMESPACE::sprintf(buff, "%#.g", 1.0);
2796   ASSERT_STREQ_LEN(written, buff, "1.");
2797 
2798   written = LIBC_NAMESPACE::sprintf(buff, "%#g", 1.0);
2799   ASSERT_STREQ_LEN(written, buff, "1.00000");
2800 
2801   written = LIBC_NAMESPACE::sprintf(buff, "%#.0g", 1.5);
2802   ASSERT_STREQ_LEN(written, buff, "2.");
2803 
2804   written = LIBC_NAMESPACE::sprintf(buff, "%015g", 1.5);
2805   ASSERT_STREQ_LEN(written, buff, "0000000000001.5");
2806 
2807   written = LIBC_NAMESPACE::sprintf(buff, "%015g", -1.5);
2808   ASSERT_STREQ_LEN(written, buff, "-000000000001.5");
2809 
2810   written = LIBC_NAMESPACE::sprintf(buff, "%+- #0g", 0.0);
2811   ASSERT_STREQ_LEN(written, buff, "+0.00000");
2812 
2813   // Combined Tests.
2814 
2815   written = LIBC_NAMESPACE::sprintf(buff, "%10.3g", 9.99);
2816   ASSERT_STREQ_LEN(written, buff, "      9.99");
2817 
2818   written = LIBC_NAMESPACE::sprintf(buff, "%10.2g", 9.99);
2819   ASSERT_STREQ_LEN(written, buff, "        10");
2820 
2821   written = LIBC_NAMESPACE::sprintf(buff, "%10.1g", 9.99);
2822   ASSERT_STREQ_LEN(written, buff, "     1e+01");
2823 
2824   written = LIBC_NAMESPACE::sprintf(buff, "%-10.3g", 9.99);
2825   ASSERT_STREQ_LEN(written, buff, "9.99      ");
2826 
2827   written = LIBC_NAMESPACE::sprintf(buff, "%-10.2g", 9.99);
2828   ASSERT_STREQ_LEN(written, buff, "10        ");
2829 
2830   written = LIBC_NAMESPACE::sprintf(buff, "%-10.1g", 9.99);
2831   ASSERT_STREQ_LEN(written, buff, "1e+01     ");
2832 
2833   written = LIBC_NAMESPACE::sprintf(buff, "%-10.1g", 1.0e-50);
2834   ASSERT_STREQ_LEN(written, buff, "1e-50     ");
2835 
2836   written = LIBC_NAMESPACE::sprintf(buff, "%30g", 1234567890123456789.0);
2837   ASSERT_STREQ_LEN(written, buff, "                   1.23457e+18");
2838 
2839   written = LIBC_NAMESPACE::sprintf(buff, "%-30g", 1234567890123456789.0);
2840   ASSERT_STREQ_LEN(written, buff, "1.23457e+18                   ");
2841 
2842   written = LIBC_NAMESPACE::sprintf(buff, "%25.15g", 9999999999999.99);
2843   ASSERT_STREQ_LEN(written, buff, "         9999999999999.99");
2844 
2845   written = LIBC_NAMESPACE::sprintf(buff, "%25.14g", 9999999999999.99);
2846   ASSERT_STREQ_LEN(written, buff, "           10000000000000");
2847 
2848   written = LIBC_NAMESPACE::sprintf(buff, "%25.13g", 9999999999999.99);
2849   ASSERT_STREQ_LEN(written, buff, "                    1e+13");
2850 
2851   written = LIBC_NAMESPACE::sprintf(buff, "%#12.3g %-12.3g", 0.1, 256.0);
2852   ASSERT_STREQ_LEN(written, buff, "       0.100 256         ");
2853 
2854   written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3g % 012.3g", 0.1256, 1256.0);
2855   ASSERT_STREQ_LEN(written, buff, "+0.126        0001.26e+03");
2856 }
2857 
2858 TEST(LlvmLibcSPrintfTest, FloatAutoLongDoubleConv) {
2859   char buff[1000];
2860   int written;
2861 
2862   ForceRoundingMode r(RoundingMode::Nearest);
2863 
2864   // Length Modifier Tests.
2865 
2866 // TODO: Tests for other long double types
2867 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
2868 
2869   written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xf.fffffffffffffffp+16380L);
2870   ASSERT_STREQ_LEN(written, buff, "1.18973e+4932");
2871 
2872   written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xa.aaaaaaaaaaaaaabp-7L);
2873   ASSERT_STREQ_LEN(written, buff, "0.0833333");
2874 
2875 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2876   written = LIBC_NAMESPACE::sprintf(buff, "%.60Lg", 0xa.aaaaaaaaaaaaaabp-7L);
2877   ASSERT_STREQ_LEN(
2878       written, buff,
2879       "0.0833333333333333333355920878593448009041821933351457118988037");
2880 #endif
2881 
2882 #endif // LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80
2883 
2884   written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 9.99999999999e-100L);
2885   ASSERT_STREQ_LEN(written, buff, "1e-99");
2886 
2887   written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 1e100L);
2888   ASSERT_STREQ_LEN(written, buff, "1e+100");
2889 
2890   written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 1.0L);
2891   ASSERT_STREQ_LEN(written, buff, "1");
2892 
2893   written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0.1L);
2894   ASSERT_STREQ_LEN(written, buff, "0.1");
2895 
2896   char big_buff[10000];
2897   written = LIBC_NAMESPACE::sprintf(big_buff, "%Lg", 1e1000L);
2898   ASSERT_STREQ_LEN(written, big_buff, "1e+1000");
2899 
2900   written = LIBC_NAMESPACE::sprintf(big_buff, "%Lg", 1e4900L);
2901   ASSERT_STREQ_LEN(written, big_buff, "1e+4900");
2902 }
2903 
2904 #endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
2905 
2906 #if defined(LIBC_COMPILER_HAS_FIXED_POINT) &&                                  \
2907     !defined(LIBC_COPT_PRINTF_DISABLE_FIXED_POINT)
2908 TEST(LlvmLibcSPrintfTest, FixedConv) {
2909   char buff[1000];
2910   int written;
2911 
2912   // These numeric tests are potentially a little weak, but the fuzz test is
2913   // more thorough than my handwritten tests tend to be.
2914 
2915   // TODO: Replace hex literals with their appropriate fixed point literals.
2916 
2917   written = LIBC_NAMESPACE::sprintf(buff, "%k", 0x0); // 0.0
2918   ASSERT_STREQ_LEN(written, buff, "0.000000");
2919 
2920   written = LIBC_NAMESPACE::sprintf(buff, "%k", 0x80000000); // -0.0
2921   ASSERT_STREQ_LEN(written, buff, "-0.000000");
2922 
2923   written = LIBC_NAMESPACE::sprintf(buff, "%r", 0xffff); // -fract max
2924   ASSERT_STREQ_LEN(written, buff, "-0.999969");
2925 
2926   written = LIBC_NAMESPACE::sprintf(buff, "%R", 0xffff); // unsigned fract max
2927   ASSERT_STREQ_LEN(written, buff, "0.999985");
2928 
2929   written = LIBC_NAMESPACE::sprintf(buff, "%k", 0xffffffff); // -accum max
2930   ASSERT_STREQ_LEN(written, buff, "-65535.999969");
2931 
2932   written =
2933       LIBC_NAMESPACE::sprintf(buff, "%K", 0xffffffff); // unsigned accum max
2934   ASSERT_STREQ_LEN(written, buff, "65535.999985");
2935 
2936   written = LIBC_NAMESPACE::sprintf(buff, "%r", 0x7fff); // fract max
2937   ASSERT_STREQ_LEN(written, buff, "0.999969");
2938 
2939   written = LIBC_NAMESPACE::sprintf(buff, "%k", 0x7fffffff); // accum max
2940   ASSERT_STREQ_LEN(written, buff, "65535.999969");
2941 
2942   // Length Modifier Tests.
2943 
2944   written = LIBC_NAMESPACE::sprintf(buff, "%hk", 0x0); // 0.0
2945   ASSERT_STREQ_LEN(written, buff, "0.000000");
2946 
2947   written = LIBC_NAMESPACE::sprintf(buff, "%hk", 0xffff); // -short accum max
2948   ASSERT_STREQ_LEN(written, buff, "-255.992188");
2949 
2950   written = LIBC_NAMESPACE::sprintf(buff, "%hr", 0x0); // 0.0
2951   ASSERT_STREQ_LEN(written, buff, "0.000000");
2952 
2953   written = LIBC_NAMESPACE::sprintf(buff, "%hr", 0xff); // -short fract max
2954   ASSERT_STREQ_LEN(written, buff, "-0.992188");
2955 
2956   written = LIBC_NAMESPACE::sprintf(buff, "%hK", 0x0); // 0.0
2957   ASSERT_STREQ_LEN(written, buff, "0.000000");
2958 
2959   written =
2960       LIBC_NAMESPACE::sprintf(buff, "%hK", 0xffff); // unsigned short accum max
2961   ASSERT_STREQ_LEN(written, buff, "255.996094");
2962 
2963   written = LIBC_NAMESPACE::sprintf(buff, "%hR", 0x0); // 0.0
2964   ASSERT_STREQ_LEN(written, buff, "0.000000");
2965 
2966   written =
2967       LIBC_NAMESPACE::sprintf(buff, "%hR", 0xff); // unsigned short fract max
2968   ASSERT_STREQ_LEN(written, buff, "0.996094");
2969 
2970   written = LIBC_NAMESPACE::sprintf(buff, "%lk", 0x0ll); // 0.0
2971   ASSERT_STREQ_LEN(written, buff, "0.000000");
2972 
2973   written = LIBC_NAMESPACE::sprintf(buff, "%lk",
2974                                     0xffffffffffffffff); //-long accum max
2975   ASSERT_STREQ_LEN(written, buff, "-4294967296.000000");
2976 
2977   written = LIBC_NAMESPACE::sprintf(buff, "%lr", 0x0); // 0.0
2978   ASSERT_STREQ_LEN(written, buff, "0.000000");
2979 
2980   written = LIBC_NAMESPACE::sprintf(buff, "%lr",
2981                                     0xffffffff); //-long fract max
2982   ASSERT_STREQ_LEN(written, buff, "-1.000000");
2983 
2984   written = LIBC_NAMESPACE::sprintf(buff, "%lK", 0x0ll); // 0.0
2985   ASSERT_STREQ_LEN(written, buff, "0.000000");
2986 
2987   written =
2988       LIBC_NAMESPACE::sprintf(buff, "%lK",
2989                               0xffffffffffffffff); // unsigned long accum max
2990   ASSERT_STREQ_LEN(written, buff, "4294967296.000000");
2991 
2992   written = LIBC_NAMESPACE::sprintf(buff, "%lR", 0x0); // 0.0
2993   ASSERT_STREQ_LEN(written, buff, "0.000000");
2994 
2995   written = LIBC_NAMESPACE::sprintf(buff, "%lR",
2996                                     0xffffffff); // unsigned long fract max
2997   ASSERT_STREQ_LEN(written, buff, "1.000000");
2998 
2999   // Min Width Tests.
3000 
3001   written = LIBC_NAMESPACE::sprintf(buff, "%10k", 0x0000a000); // 1.25
3002   ASSERT_STREQ_LEN(written, buff, "  1.250000");
3003 
3004   written = LIBC_NAMESPACE::sprintf(buff, "%10k", 0x8000a000); //-1.25
3005   ASSERT_STREQ_LEN(written, buff, " -1.250000");
3006 
3007   written = LIBC_NAMESPACE::sprintf(buff, "%8k", 0x0000a000); // 1.25
3008   ASSERT_STREQ_LEN(written, buff, "1.250000");
3009 
3010   written = LIBC_NAMESPACE::sprintf(buff, "%9k", 0x8000a000); //-1.25
3011   ASSERT_STREQ_LEN(written, buff, "-1.250000");
3012 
3013   written = LIBC_NAMESPACE::sprintf(buff, "%4k", 0x0000a000); // 1.25
3014   ASSERT_STREQ_LEN(written, buff, "1.250000");
3015 
3016   written = LIBC_NAMESPACE::sprintf(buff, "%4k", 0x8000a000); //-1.25
3017   ASSERT_STREQ_LEN(written, buff, "-1.250000");
3018 
3019   // Precision Tests.
3020 
3021   written =
3022       LIBC_NAMESPACE::sprintf(buff, "%.16K", 0xFFFFFFFF); // unsigned accum max
3023   ASSERT_STREQ_LEN(written, buff, "65535.9999847412109375");
3024 
3025   written = LIBC_NAMESPACE::sprintf(
3026       buff, "%.32lK", 0xFFFFFFFFFFFFFFFF); // unsigned long accum max
3027   ASSERT_STREQ_LEN(written, buff,
3028                    "4294967295.99999999976716935634613037109375");
3029 
3030   written =
3031       LIBC_NAMESPACE::sprintf(buff, "%.0K", 0xFFFFFFFF); // unsigned accum max
3032   ASSERT_STREQ_LEN(written, buff, "65536");
3033 
3034   written = LIBC_NAMESPACE::sprintf(buff, "%.0R", 0xFFFF); // unsigned fract max
3035   ASSERT_STREQ_LEN(written, buff, "1");
3036 
3037   // Flag Tests.
3038 
3039   written = LIBC_NAMESPACE::sprintf(buff, "%+k", 0x0000a000); // 1.25
3040   ASSERT_STREQ_LEN(written, buff, "+1.250000");
3041 
3042   written = LIBC_NAMESPACE::sprintf(buff, "%+k", 0x8000a000); //-1.25
3043   ASSERT_STREQ_LEN(written, buff, "-1.250000");
3044 
3045   written = LIBC_NAMESPACE::sprintf(buff, "% k", 0x0000a000); // 1.25
3046   ASSERT_STREQ_LEN(written, buff, " 1.250000");
3047 
3048   written = LIBC_NAMESPACE::sprintf(buff, "% k", 0x8000a000); //-1.25
3049   ASSERT_STREQ_LEN(written, buff, "-1.250000");
3050 
3051   // unsigned variants ignore sign flags.
3052   written = LIBC_NAMESPACE::sprintf(buff, "%+K", 0x00014000); // 1.25
3053   ASSERT_STREQ_LEN(written, buff, "1.250000");
3054 
3055   written = LIBC_NAMESPACE::sprintf(buff, "% K", 0x00014000); // 1.25
3056   ASSERT_STREQ_LEN(written, buff, "1.250000");
3057 
3058   written = LIBC_NAMESPACE::sprintf(buff, "%-10k", 0x0000c000); // 1.5
3059   ASSERT_STREQ_LEN(written, buff, "1.500000  ");
3060 
3061   written = LIBC_NAMESPACE::sprintf(buff, "%#.k", 0x00008000); // 1.0
3062   ASSERT_STREQ_LEN(written, buff, "1.");
3063 
3064   written = LIBC_NAMESPACE::sprintf(buff, "%#.0k", 0x0000c000); // 1.5
3065   ASSERT_STREQ_LEN(written, buff, "2.");
3066 
3067   written = LIBC_NAMESPACE::sprintf(buff, "%010k", 0x0000c000); // 1.5
3068   ASSERT_STREQ_LEN(written, buff, "001.500000");
3069 
3070   written = LIBC_NAMESPACE::sprintf(buff, "%010k", 0x8000c000); //-1.5
3071   ASSERT_STREQ_LEN(written, buff, "-01.500000");
3072 
3073   written = LIBC_NAMESPACE::sprintf(buff, "%+- #0k", 0); // 0.0
3074   ASSERT_STREQ_LEN(written, buff, "+0.000000");
3075 
3076   // Combined Tests.
3077 
3078   written = LIBC_NAMESPACE::sprintf(buff, "%10.2k", 0x0004feb8); // 9.99
3079   ASSERT_STREQ_LEN(written, buff, "      9.99");
3080 
3081   written = LIBC_NAMESPACE::sprintf(buff, "%5.1k", 0x0004feb8); // 9.99
3082   ASSERT_STREQ_LEN(written, buff, " 10.0");
3083 
3084   written = LIBC_NAMESPACE::sprintf(buff, "%-10.2k", 0x0004feb8); // 9.99
3085   ASSERT_STREQ_LEN(written, buff, "9.99      ");
3086 
3087   written = LIBC_NAMESPACE::sprintf(buff, "%-5.1k", 0x0004feb8); // 9.99
3088   ASSERT_STREQ_LEN(written, buff, "10.0 ");
3089 
3090   written = LIBC_NAMESPACE::sprintf(buff, "%-5.1k", 0x00000001); // accum min
3091   ASSERT_STREQ_LEN(written, buff, "0.0  ");
3092 
3093   written = LIBC_NAMESPACE::sprintf(buff, "%30k", 0x7fffffff); // accum max
3094   ASSERT_STREQ_LEN(written, buff, "                  65535.999969");
3095 
3096   written = LIBC_NAMESPACE::sprintf(buff, "%-30k", 0x7fffffff); // accum max
3097   ASSERT_STREQ_LEN(written, buff, "65535.999969                  ");
3098 
3099   written = LIBC_NAMESPACE::sprintf(buff, "%20.2lK",
3100                                     0x3b9ac9ffFD70A3D7); // 999999999.99
3101   ASSERT_STREQ_LEN(written, buff, "        999999999.99");
3102 
3103   written = LIBC_NAMESPACE::sprintf(buff, "%20.1lK",
3104                                     0x3b9ac9ffFD70A3D7); // 999999999.99
3105   ASSERT_STREQ_LEN(written, buff, "        1000000000.0");
3106 
3107   written = LIBC_NAMESPACE::sprintf(buff, "%12.3R %-12.3k", 0x1999,
3108                                     0x00800000); // 0.1, 256.0
3109   ASSERT_STREQ_LEN(written, buff, "       0.100 256.000     ");
3110 
3111   written =
3112       LIBC_NAMESPACE::sprintf(buff, "%+-#12.3lk % 012.3k", 0x000000001013a92all,
3113                               0x02740000); // 0.126, 1256.0
3114   ASSERT_STREQ_LEN(written, buff, "+0.126        0001256.000");
3115 }
3116 #endif // defined(LIBC_COMPILER_HAS_FIXED_POINT) &&
3117        // !defined(LIBC_COPT_PRINTF_DISABLE_FIXED_POINT)
3118 
3119 #ifndef LIBC_COPT_PRINTF_DISABLE_STRERROR
3120 TEST(LlvmLibcSPrintfTest, StrerrorConv) {
3121   char buff[1000];
3122   int written;
3123 
3124   LIBC_NAMESPACE::libc_errno = 0;
3125   written = LIBC_NAMESPACE::sprintf(buff, "%m");
3126   ASSERT_STREQ_LEN(written, buff, "Success");
3127 
3128   LIBC_NAMESPACE::libc_errno = ERANGE;
3129   written = LIBC_NAMESPACE::sprintf(buff, "%m");
3130   ASSERT_STREQ_LEN(written, buff, "Numerical result out of range");
3131 
3132   // Check that it correctly consumes no arguments.
3133   LIBC_NAMESPACE::libc_errno = 0;
3134   written = LIBC_NAMESPACE::sprintf(buff, "%m %d", 1);
3135   ASSERT_STREQ_LEN(written, buff, "Success 1");
3136 
3137   // Width Tests
3138 
3139   LIBC_NAMESPACE::libc_errno = 0;
3140   written = LIBC_NAMESPACE::sprintf(buff, "%10m");
3141   ASSERT_STREQ_LEN(written, buff, "   Success");
3142 
3143   LIBC_NAMESPACE::libc_errno = ERANGE;
3144   written = LIBC_NAMESPACE::sprintf(buff, "%10m");
3145   ASSERT_STREQ_LEN(written, buff, "Numerical result out of range");
3146 
3147   // Precision Tests
3148 
3149   LIBC_NAMESPACE::libc_errno = 0;
3150   written = LIBC_NAMESPACE::sprintf(buff, "%.10m");
3151   ASSERT_STREQ_LEN(written, buff, "Success");
3152 
3153   LIBC_NAMESPACE::libc_errno = ERANGE;
3154   written = LIBC_NAMESPACE::sprintf(buff, "%.10m");
3155   ASSERT_STREQ_LEN(written, buff, "Numerical ");
3156 
3157   // Flag Tests (Only '-' since the others only affect ints)
3158 
3159   LIBC_NAMESPACE::libc_errno = 0;
3160   written = LIBC_NAMESPACE::sprintf(buff, "%-10m");
3161   ASSERT_STREQ_LEN(written, buff, "Success   ");
3162 
3163   LIBC_NAMESPACE::libc_errno = ERANGE;
3164   written = LIBC_NAMESPACE::sprintf(buff, "%-10m");
3165   ASSERT_STREQ_LEN(written, buff, "Numerical result out of range");
3166 
3167   // Alt Mode Tests
3168   // Since alt mode here is effectively a completely separate conversion, it
3169   // gets separate tests.
3170 
3171   LIBC_NAMESPACE::libc_errno = 0;
3172   written = LIBC_NAMESPACE::sprintf(buff, "%#m");
3173   ASSERT_STREQ_LEN(written, buff, "0");
3174 
3175   LIBC_NAMESPACE::libc_errno = ERANGE;
3176   written = LIBC_NAMESPACE::sprintf(buff, "%#m");
3177   ASSERT_STREQ_LEN(written, buff, "ERANGE");
3178 
3179   LIBC_NAMESPACE::libc_errno = -9999;
3180   written = LIBC_NAMESPACE::sprintf(buff, "%#m");
3181   ASSERT_STREQ_LEN(written, buff, "-9999");
3182 
3183   // Alt Mode Width
3184 
3185   LIBC_NAMESPACE::libc_errno = 0;
3186   written = LIBC_NAMESPACE::sprintf(buff, "%#10m");
3187   ASSERT_STREQ_LEN(written, buff, "         0");
3188 
3189   LIBC_NAMESPACE::libc_errno = ERANGE;
3190   written = LIBC_NAMESPACE::sprintf(buff, "%#10m");
3191   ASSERT_STREQ_LEN(written, buff, "    ERANGE");
3192 
3193   LIBC_NAMESPACE::libc_errno = -9999;
3194   written = LIBC_NAMESPACE::sprintf(buff, "%#10m");
3195   ASSERT_STREQ_LEN(written, buff, "     -9999");
3196 
3197   LIBC_NAMESPACE::libc_errno = ERANGE;
3198   written = LIBC_NAMESPACE::sprintf(buff, "%#3m");
3199   ASSERT_STREQ_LEN(written, buff, "ERANGE");
3200 
3201   LIBC_NAMESPACE::libc_errno = -9999;
3202   written = LIBC_NAMESPACE::sprintf(buff, "%#3m");
3203   ASSERT_STREQ_LEN(written, buff, "-9999");
3204 
3205   // Alt Mode Precision
3206 
3207   LIBC_NAMESPACE::libc_errno = ERANGE;
3208   written = LIBC_NAMESPACE::sprintf(buff, "%#.10m");
3209   ASSERT_STREQ_LEN(written, buff, "ERANGE");
3210 
3211   LIBC_NAMESPACE::libc_errno = -9999;
3212   written = LIBC_NAMESPACE::sprintf(buff, "%#.10m");
3213   ASSERT_STREQ_LEN(written, buff, "-0000009999");
3214 
3215   LIBC_NAMESPACE::libc_errno = ERANGE;
3216   written = LIBC_NAMESPACE::sprintf(buff, "%#.3m");
3217   ASSERT_STREQ_LEN(written, buff, "ERA");
3218 
3219   LIBC_NAMESPACE::libc_errno = -9999;
3220   written = LIBC_NAMESPACE::sprintf(buff, "%#.3m");
3221   ASSERT_STREQ_LEN(written, buff, "-9999");
3222 
3223   // We don't test precision (or int flags) on errno = 0 because it behaves
3224   // weirdly, see the docs for more information.
3225   LIBC_NAMESPACE::libc_errno = 0;
3226   written = LIBC_NAMESPACE::sprintf(buff, "%#.1m");
3227   ASSERT_STREQ_LEN(written, buff, "0");
3228 
3229   // Alt Mode Flags
3230 
3231   // '-' flag
3232   LIBC_NAMESPACE::libc_errno = 0;
3233   written = LIBC_NAMESPACE::sprintf(buff, "%#-10m");
3234   ASSERT_STREQ_LEN(written, buff, "0         ");
3235 
3236   LIBC_NAMESPACE::libc_errno = ERANGE;
3237   written = LIBC_NAMESPACE::sprintf(buff, "%#-10m");
3238   ASSERT_STREQ_LEN(written, buff, "ERANGE    ");
3239 
3240   LIBC_NAMESPACE::libc_errno = -9999;
3241   written = LIBC_NAMESPACE::sprintf(buff, "%#-10m");
3242   ASSERT_STREQ_LEN(written, buff, "-9999     ");
3243 
3244   LIBC_NAMESPACE::libc_errno = ERANGE;
3245   written = LIBC_NAMESPACE::sprintf(buff, "%#-3m");
3246   ASSERT_STREQ_LEN(written, buff, "ERANGE");
3247 
3248   LIBC_NAMESPACE::libc_errno = -9999;
3249   written = LIBC_NAMESPACE::sprintf(buff, "%#-3m");
3250   ASSERT_STREQ_LEN(written, buff, "-9999");
3251 
3252   // '+' flag
3253   LIBC_NAMESPACE::libc_errno = ERANGE;
3254   written = LIBC_NAMESPACE::sprintf(buff, "%#+m");
3255   ASSERT_STREQ_LEN(written, buff, "ERANGE");
3256 
3257   LIBC_NAMESPACE::libc_errno = -9999;
3258   written = LIBC_NAMESPACE::sprintf(buff, "%#+m");
3259   ASSERT_STREQ_LEN(written, buff, "-9999");
3260 
3261   // Technically 9999 could be a valid error, since the standard just says errno
3262   // macros are "distinct positive values". In practice I don't expect this to
3263   // come up, but I've avoided it for the other %m tests for ease of
3264   // refactoring if necessary. Here it needs to be positive to test that the
3265   // flags that only affect positive signed integers are properly passed along.
3266   LIBC_NAMESPACE::libc_errno = 9999;
3267   written = LIBC_NAMESPACE::sprintf(buff, "%#+m");
3268   ASSERT_STREQ_LEN(written, buff, "+9999");
3269 
3270   // ' ' flag
3271   LIBC_NAMESPACE::libc_errno = ERANGE;
3272   written = LIBC_NAMESPACE::sprintf(buff, "%# m");
3273   ASSERT_STREQ_LEN(written, buff, "ERANGE");
3274 
3275   LIBC_NAMESPACE::libc_errno = -9999;
3276   written = LIBC_NAMESPACE::sprintf(buff, "%# m");
3277   ASSERT_STREQ_LEN(written, buff, "-9999");
3278 
3279   LIBC_NAMESPACE::libc_errno = 9999;
3280   written = LIBC_NAMESPACE::sprintf(buff, "%# m");
3281   ASSERT_STREQ_LEN(written, buff, " 9999");
3282 
3283   // '0' flag
3284 
3285   LIBC_NAMESPACE::libc_errno = ERANGE;
3286   written = LIBC_NAMESPACE::sprintf(buff, "%#010m");
3287   ASSERT_STREQ_LEN(written, buff, "    ERANGE");
3288 
3289   LIBC_NAMESPACE::libc_errno = -9999;
3290   written = LIBC_NAMESPACE::sprintf(buff, "%#010m");
3291   ASSERT_STREQ_LEN(written, buff, "-000009999");
3292 
3293   LIBC_NAMESPACE::libc_errno = ERANGE;
3294   written = LIBC_NAMESPACE::sprintf(buff, "%#03m");
3295   ASSERT_STREQ_LEN(written, buff, "ERANGE");
3296 
3297   LIBC_NAMESPACE::libc_errno = -9999;
3298   written = LIBC_NAMESPACE::sprintf(buff, "%#03m");
3299   ASSERT_STREQ_LEN(written, buff, "-9999");
3300 }
3301 #endif // LIBC_COPT_PRINTF_DISABLE_STRERROR
3302 
3303 #ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
3304 TEST(LlvmLibcSPrintfTest, WriteIntConv) {
3305   char buff[64];
3306   int written;
3307   int test_val = -1;
3308 
3309   test_val = -1;
3310   written = LIBC_NAMESPACE::sprintf(buff, "12345%n67890", &test_val);
3311   EXPECT_EQ(test_val, 5);
3312   ASSERT_STREQ_LEN(written, buff, "1234567890");
3313 
3314   test_val = -1;
3315   written = LIBC_NAMESPACE::sprintf(buff, "%n", &test_val);
3316   EXPECT_EQ(test_val, 0);
3317   ASSERT_STREQ_LEN(written, buff, "");
3318 
3319   test_val = 0x100;
3320   written = LIBC_NAMESPACE::sprintf(buff, "ABC%hhnDEF", &test_val);
3321   EXPECT_EQ(test_val, 0x103);
3322   ASSERT_STREQ_LEN(written, buff, "ABCDEF");
3323 
3324   test_val = -1;
3325   written = LIBC_NAMESPACE::sprintf(buff, "%s%n", "87654321", &test_val);
3326   EXPECT_EQ(test_val, 8);
3327   ASSERT_STREQ_LEN(written, buff, "87654321");
3328 
3329 #ifndef LIBC_COPT_PRINTF_NO_NULLPTR_CHECKS
3330   written = LIBC_NAMESPACE::sprintf(buff, "abc123%n", nullptr);
3331   EXPECT_LT(written, 0);
3332 #endif // LIBC_COPT_PRINTF_NO_NULLPTR_CHECKS
3333 }
3334 #endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
3335 
3336 #ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
3337 TEST(LlvmLibcSPrintfTest, IndexModeParsing) {
3338   char buff[64];
3339   int written;
3340 
3341   written = LIBC_NAMESPACE::sprintf(buff, "%1$s", "abcDEF123");
3342   ASSERT_STREQ_LEN(written, buff, "abcDEF123");
3343 
3344   written = LIBC_NAMESPACE::sprintf(buff, "%1$s %%", "abcDEF123");
3345   ASSERT_STREQ_LEN(written, buff, "abcDEF123 %");
3346 
3347   written =
3348       LIBC_NAMESPACE::sprintf(buff, "%3$s %1$s %2$s", "is", "hard", "ordering");
3349   ASSERT_STREQ_LEN(written, buff, "ordering is hard");
3350 
3351   written = LIBC_NAMESPACE::sprintf(
3352       buff, "%10$s %9$s %8$c %7$s %6$s, %6$s %5$s %4$-*1$s %3$.*11$s %2$s. %%",
3353       6, "pain", "alphabetical", "such", "is", "this", "do", 'u', "would",
3354       "why", 1);
3355   ASSERT_STREQ_LEN(written, buff,
3356                    "why would u do this, this is such   a pain. %");
3357 }
3358 #endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
3359