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/__support/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	#if defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
1866	// Some exceptionally difficult cases for 39-digit precision. (That's the
1867	// number of digits supported by the float320 algorithm, and should still be
1868	// correct under other algorithms. So these are still enabled even under
1869	// LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION.)
1870	//
1871	// These were found by number-theoretic search to be the worst cases in terms
1872	// of being extremely close to the rounding boundary between two possible
1873	// decimal outputs. For example, the first of these cases has a true value
1874	// beginning with
1875	//
1876	// 2.245786964418815522831613614422112838795000000000000000000
1877	// 0000000000000000010767969...
1878	//
1879	// so you need to compute a _long_ way past the 39th digit to find out
1880	// whether to round the ...8795 up to 880 or not!
1881	//
1882	// The first half of these cases all rounded up; the second half all rounded
1883	// down. You can see that in both sections the final decimal digit is
1884	// sometimes odd and sometimes even, ruling out the possibility that we're
1885	// getting these right by mistakenly assuming them to be _exactly_ on the
1886	// boundary.
1887
1888	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1889	0x1.bde5716bba8d70255b4be10e0a0ap-3388L);
1890	ASSERT_STREQ_LEN(written, buff,
1891	"2.24578696441881552283161361442211283880e-1020");
1892	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1893	0x1.64b78defc8712684490980d80808p-3391L);
1894	ASSERT_STREQ_LEN(written, buff,
1895	"2.24578696441881552283161361442211283880e-1021");
1896	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1897	0x1.c0eed9d1ea4b6f215accb15cb42cp-4714L);
1898	ASSERT_STREQ_LEN(written, buff,
1899	"1.54362575487963943466308346767014523161e-1419");
1900	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1901	0x1.a393eaafc3dbabfcd30442cef525p-12600L);
1902	ASSERT_STREQ_LEN(written, buff,
1903	"1.72435694193924008931441874634575361189e-3793");
1904	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1905	0x1.b7a5248baf85133c9b7bf3241f75p+11050L);
1906	ASSERT_STREQ_LEN(written, buff,
1907	"4.13346579244549095104252956440178208514e+3326");
1908	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1909	0x1.81bf6d977f99ff7bd9debdd52815p+1359L);
1910	ASSERT_STREQ_LEN(written, buff,
1911	"1.89595297593127274811683259716608232064e+409");
1912	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1913	0x1.fcb9cfd65f068b758d30ba19a494p-4451L);
1914	ASSERT_STREQ_LEN(written, buff,
1915	"2.59258570015527007681686041122929728653e-1340");
1916	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1917	0x1.7d8b5be0c744e89829e48b933b6fp-4448L);
1918	ASSERT_STREQ_LEN(written, buff,
1919	"1.55555142009316204609011624673757837192e-1339");
1920	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1921	0x1.dbb1f01aef7b93c37ca00217888cp-12205L);
1922	ASSERT_STREQ_LEN(written, buff,
1923	"1.57758077908296078543773740016012372216e-3674");
1924	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1925	0x1.fb037d72fdf1a8aa8bdfc2586fe3p+2580L);
1926	ASSERT_STREQ_LEN(written, buff,
1927	"8.99846610004600287527755301065037553046e+776");
1928
1929	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1930	0x1.9af8fe5febf751a795292e30335dp+2052L);
1931	ASSERT_STREQ_LEN(written, buff,
1932	"8.30087814106622071390265113980150545241e+617");
1933	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1934	0x1.48c731e6565f748610edbe8cf5e4p+2049L);
1935	ASSERT_STREQ_LEN(written, buff,
1936	"8.30087814106622071390265113980150545241e+616");
1937	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1938	0x1.8e78bc76e98998b7bbf6c8f80f2ap-5671L);
1939	ASSERT_STREQ_LEN(written, buff,
1940	"1.12473970318904704063044350553302771341e-1707");
1941	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1942	0x1.59a832c16a7797aec70196ddf9dbp-16181L);
1943	ASSERT_STREQ_LEN(written, buff,
1944	"1.45896738321434823250358135932839533040e-4871");
1945	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1946	0x1.14868f0121f946256c01457e617cp-16184L);
1947	ASSERT_STREQ_LEN(written, buff,
1948	"1.45896738321434823250358135932839533040e-4872");
1949	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1950	0x1.0ca8c4b525b1128506cdc668df43p+11017L);
1951	ASSERT_STREQ_LEN(written, buff,
1952	"2.94051951004764266903705588743096762647e+3316");
1953	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1954	0x1.fcd40bb49b18aa19d66a3c5572dep+5547L);
1955	ASSERT_STREQ_LEN(written, buff,
1956	"1.29335350323078956384272678475060580129e+1670");
1957	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1958	0x1.0e5e51510a653e744d6b84efed86p-13613L);
1959	ASSERT_STREQ_LEN(written, buff,
1960	"1.26585813611514592337442314391432904094e-4098");
1961	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1962	0x1.ff41f8aa97e676e95b1a6a7751fap+16366L);
1963	ASSERT_STREQ_LEN(written, buff,
1964	"9.06377119787295161934827646572467920486e+4926");
1965	written = LIBC_NAMESPACE::sprintf(buff, "%#.39Lg",
1966	0x1.4770bf66ccafd7d80ac9bb3dded7p-1843L);
1967	ASSERT_STREQ_LEN(written, buff,
1968	"2.03521509642091239545213340619368190283e-555");
1969
1970	#endif // LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128
1971	}
1972
1973	TEST(LlvmLibcSPrintfTest, FloatExponentConv) {
1974	char buff[1000];
1975	int written;
1976
1977	ForceRoundingMode r(RoundingMode::Nearest);
1978	double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
1979	double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
1980
1981	written = LIBC_NAMESPACE::sprintf(buff, "%e", 1.0);
1982	ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
1983
1984	written = LIBC_NAMESPACE::sprintf(buff, "%E", -1.0);
1985	ASSERT_STREQ_LEN(written, buff, "-1.000000E+00");
1986
1987	written = LIBC_NAMESPACE::sprintf(buff, "%e", -1.234567);
1988	ASSERT_STREQ_LEN(written, buff, "-1.234567e+00");
1989
1990	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.0);
1991	ASSERT_STREQ_LEN(written, buff, "0.000000e+00");
1992
1993	written = LIBC_NAMESPACE::sprintf(buff, "%e", 1.5);
1994	ASSERT_STREQ_LEN(written, buff, "1.500000e+00");
1995
1996	written = LIBC_NAMESPACE::sprintf(buff, "%e", 1e300);
1997	ASSERT_STREQ_LEN(written, buff, "1.000000e+300");
1998
1999	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.1);
2000	ASSERT_STREQ_LEN(written, buff, "1.000000e-01");
2001
2002	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.001);
2003	ASSERT_STREQ_LEN(written, buff, "1.000000e-03");
2004
2005	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.00001);
2006	ASSERT_STREQ_LEN(written, buff, "1.000000e-05");
2007
2008	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.0000001);
2009	ASSERT_STREQ_LEN(written, buff, "1.000000e-07");
2010
2011	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0.000000001);
2012	ASSERT_STREQ_LEN(written, buff, "1.000000e-09");
2013
2014	written = LIBC_NAMESPACE::sprintf(buff, "%e", 1.0e-20);
2015	ASSERT_STREQ_LEN(written, buff, "1.000000e-20");
2016
2017	written = LIBC_NAMESPACE::sprintf(buff, "%e", 1234567890123456789.0);
2018	ASSERT_STREQ_LEN(written, buff, "1.234568e+18");
2019
2020	written = LIBC_NAMESPACE::sprintf(buff, "%e", 9999999000000.00);
2021	ASSERT_STREQ_LEN(written, buff, "9.999999e+12");
2022
2023	// Simple Subnormal Tests.
2024
2025	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0x1.0p-1027);
2026	ASSERT_STREQ_LEN(written, buff, "6.953356e-310");
2027
2028	written = LIBC_NAMESPACE::sprintf(buff, "%e", 0x1.0p-1074);
2029	ASSERT_STREQ_LEN(written, buff, "4.940656e-324");
2030
2031	// Inf/Nan Tests.
2032
2033	written = LIBC_NAMESPACE::sprintf(buff, "%e", inf);
2034	ASSERT_STREQ_LEN(written, buff, "inf");
2035
2036	written = LIBC_NAMESPACE::sprintf(buff, "%E", -inf);
2037	ASSERT_STREQ_LEN(written, buff, "-INF");
2038
2039	written = LIBC_NAMESPACE::sprintf(buff, "%e", nan);
2040	ASSERT_STREQ_LEN(written, buff, "nan");
2041
2042	written = LIBC_NAMESPACE::sprintf(buff, "%E", -nan);
2043	ASSERT_STREQ_LEN(written, buff, "-NAN");
2044
2045	// Min Width Tests.
2046
2047	written = LIBC_NAMESPACE::sprintf(buff, "%15e", 1.0);
2048	ASSERT_STREQ_LEN(written, buff, " 1.000000e+00");
2049
2050	written = LIBC_NAMESPACE::sprintf(buff, "%15e", -1.0);
2051	ASSERT_STREQ_LEN(written, buff, " -1.000000e+00");
2052
2053	written = LIBC_NAMESPACE::sprintf(buff, "%15e", 1.0e5);
2054	ASSERT_STREQ_LEN(written, buff, " 1.000000e+05");
2055
2056	written = LIBC_NAMESPACE::sprintf(buff, "%15e", -1.0e5);
2057	ASSERT_STREQ_LEN(written, buff, " -1.000000e+05");
2058
2059	written = LIBC_NAMESPACE::sprintf(buff, "%10e", 1.0e-5);
2060	ASSERT_STREQ_LEN(written, buff, "1.000000e-05");
2061
2062	// Precision Tests.
2063
2064	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.0);
2065	ASSERT_STREQ_LEN(written, buff, "1.0e+00");
2066
2067	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 0.0);
2068	ASSERT_STREQ_LEN(written, buff, "0.0e+00");
2069
2070	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 0.0);
2071	ASSERT_STREQ_LEN(written, buff, "0e+00");
2072
2073	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 0.1);
2074	ASSERT_STREQ_LEN(written, buff, "1.0e-01");
2075
2076	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.09);
2077	ASSERT_STREQ_LEN(written, buff, "1.1e+00");
2078
2079	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.04);
2080	ASSERT_STREQ_LEN(written, buff, "1.0e+00");
2081
2082	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.19);
2083	ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2084
2085	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.99);
2086	ASSERT_STREQ_LEN(written, buff, "2.0e+00");
2087
2088	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 9.99);
2089	ASSERT_STREQ_LEN(written, buff, "1.0e+01");
2090
2091	written = LIBC_NAMESPACE::sprintf(buff, "%.2e", 99.9);
2092	ASSERT_STREQ_LEN(written, buff, "9.99e+01");
2093
2094	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 99.9);
2095	ASSERT_STREQ_LEN(written, buff, "1.0e+02");
2096
2097	written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 1.25);
2098	ASSERT_STREQ_LEN(written, buff, "1.25000e+00");
2099
2100	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 1.25);
2101	ASSERT_STREQ_LEN(written, buff, "1e+00");
2102
2103	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 1.75);
2104	ASSERT_STREQ_LEN(written, buff, "2e+00");
2105
2106	written = LIBC_NAMESPACE::sprintf(buff, "%.20e", 1.234e-10);
2107	ASSERT_STREQ_LEN(written, buff, "1.23400000000000008140e-10");
2108
2109	written = LIBC_NAMESPACE::sprintf(buff, "%.2e", -9.99);
2110	ASSERT_STREQ_LEN(written, buff, "-9.99e+00");
2111
2112	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -9.99);
2113	ASSERT_STREQ_LEN(written, buff, "-1.0e+01");
2114
2115	written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 0.0);
2116	ASSERT_STREQ_LEN(written, buff, "0.00000e+00");
2117
2118	written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 1.008);
2119	ASSERT_STREQ_LEN(written, buff, "1.00800e+00");
2120
2121	written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 1.008e3);
2122	ASSERT_STREQ_LEN(written, buff, "1.00800e+03");
2123
2124	// These tests also focus on rounding. Almost all of them have a 5 right after
2125	// the printed string (e.g. 9.5 with precision 0 prints 0 digits after the
2126	// decimal point). This is again because rounding a number with a 5 after the
2127	// printed section means that more digits have to be checked to determine if
2128	// this should be rounded up (if there are non-zero digits after the 5) or to
2129	// even (if the 5 is the last non-zero digit). Additionally, the algorithm for
2130	// checking if a number is all 0s after the decimal point may not work since
2131	// the decimal point moves in this representation.
2132	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 2.5812229360061737E+200);
2133	ASSERT_STREQ_LEN(written, buff, "3e+200");
2134
2135	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 9.059E+200);
2136	ASSERT_STREQ_LEN(written, buff, "9.1e+200");
2137
2138	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 9.059E+200);
2139	ASSERT_STREQ_LEN(written, buff, "9e+200");
2140
2141	#ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2142	written = LIBC_NAMESPACE::sprintf(buff, "%.166e", 1.131959884853339E-72);
2143	ASSERT_STREQ_LEN(written, buff,
2144	"1."
2145	"13195988485333904593863991136097397258531639976739227369782"
2146	"68612419376648241056393424414314951197624317440549121097287"
2147	"069853416091591569170304865110665559768676757812e-72");
2148	#endif
2149
2150	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 9.5);
2151	ASSERT_STREQ_LEN(written, buff, "1e+01");
2152
2153	written = LIBC_NAMESPACE::sprintf(buff, "%.10e", 1.9999999999890936);
2154	ASSERT_STREQ_LEN(written, buff, "2.0000000000e+00");
2155
2156	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 745362143563.03894);
2157	ASSERT_STREQ_LEN(written, buff, "7.5e+11");
2158
2159	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 45181042688.0);
2160	ASSERT_STREQ_LEN(written, buff, "5e+10");
2161
2162	written = LIBC_NAMESPACE::sprintf(buff, "%.35e", 1.3752441369139243);
2163	ASSERT_STREQ_LEN(written, buff, "1.37524413691392433101157166674965993e+00");
2164
2165	// Subnormal Precision Tests
2166
2167	#ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2168	written = LIBC_NAMESPACE::sprintf(buff, "%.310e", 0x1.0p-1022);
2169	ASSERT_STREQ_LEN(
2170	written, buff,
2171	"2."
2172	"225073858507201383090232717332404064219215980462331830553327416887204434"
2173	"813918195854283159012511020564067339731035811005152434161553460108856012"
2174	"385377718821130777993532002330479610147442583636071921565046942503734208"
2175	"375250806650616658158948720491179968591639648500635908770118304874799780"
2176	"8877537499494515804516e-308");
2177	#endif
2178
2179	written = LIBC_NAMESPACE::sprintf(buff, "%.30e", 0x1.0p-1022);
2180	ASSERT_STREQ_LEN(written, buff, "2.225073858507201383090232717332e-308");
2181
2182	#ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2183	written = LIBC_NAMESPACE::sprintf(buff, "%.310e", 0x1.0p-1023);
2184	ASSERT_STREQ_LEN(
2185	written, buff,
2186	"1."
2187	"112536929253600691545116358666202032109607990231165915276663708443602217"
2188	"406959097927141579506255510282033669865517905502576217080776730054428006"
2189	"192688859410565388996766001165239805073721291818035960782523471251867104"
2190	"187625403325308329079474360245589984295819824250317954385059152437399890"
2191	"4438768749747257902258e-308");
2192	#endif
2193
2194	written = LIBC_NAMESPACE::sprintf(buff, "%.6e", 9.99999e-310);
2195	ASSERT_STREQ_LEN(written, buff, "9.999990e-310");
2196
2197	written = LIBC_NAMESPACE::sprintf(buff, "%.5e", 9.99999e-310);
2198	ASSERT_STREQ_LEN(written, buff, "9.99999e-310");
2199
2200	written = LIBC_NAMESPACE::sprintf(buff, "%.4e", 9.99999e-310);
2201	ASSERT_STREQ_LEN(written, buff, "1.0000e-309");
2202
2203	written = LIBC_NAMESPACE::sprintf(buff, "%.3e", 9.99999e-310);
2204	ASSERT_STREQ_LEN(written, buff, "1.000e-309");
2205
2206	written = LIBC_NAMESPACE::sprintf(buff, "%.2e", 9.99999e-310);
2207	ASSERT_STREQ_LEN(written, buff, "1.00e-309");
2208
2209	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 9.99999e-310);
2210	ASSERT_STREQ_LEN(written, buff, "1.0e-309");
2211
2212	written = LIBC_NAMESPACE::sprintf(buff, "%.0e", 9.99999e-310);
2213	ASSERT_STREQ_LEN(written, buff, "1e-309");
2214
2215	written = LIBC_NAMESPACE::sprintf(buff, "%.10e", 0x1.0p-1074);
2216	ASSERT_STREQ_LEN(written, buff, "4.9406564584e-324");
2217
2218	// Rounding Mode Tests.
2219
2220	if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
2221	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2222	ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2223
2224	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2225	ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2226
2227	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2228	ASSERT_STREQ_LEN(written, buff, "1.1e+00");
2229
2230	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2231	ASSERT_STREQ_LEN(written, buff, "1.6e+00");
2232
2233	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2234	ASSERT_STREQ_LEN(written, buff, "1.4e+00");
2235
2236	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2237	ASSERT_STREQ_LEN(written, buff, "1.9e+00");
2238
2239	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2240	ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2241
2242	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2243	ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2244
2245	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2246	ASSERT_STREQ_LEN(written, buff, "-1.1e+00");
2247
2248	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2249	ASSERT_STREQ_LEN(written, buff, "-1.6e+00");
2250
2251	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2252	ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
2253
2254	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2255	ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
2256	}
2257
2258	if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
2259	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2260	ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2261
2262	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2263	ASSERT_STREQ_LEN(written, buff, "1.3e+00");
2264
2265	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2266	ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2267
2268	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2269	ASSERT_STREQ_LEN(written, buff, "1.7e+00");
2270
2271	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2272	ASSERT_STREQ_LEN(written, buff, "1.4e+00");
2273
2274	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2275	ASSERT_STREQ_LEN(written, buff, "1.9e+00");
2276
2277	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2278	ASSERT_STREQ_LEN(written, buff, "-1.7e+00");
2279
2280	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2281	ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2282
2283	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2284	ASSERT_STREQ_LEN(written, buff, "-1.1e+00");
2285
2286	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2287	ASSERT_STREQ_LEN(written, buff, "-1.6e+00");
2288
2289	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2290	ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
2291
2292	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2293	ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2294	}
2295
2296	if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
2297	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2298	ASSERT_STREQ_LEN(written, buff, "1.7e+00");
2299
2300	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2301	ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2302
2303	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2304	ASSERT_STREQ_LEN(written, buff, "1.1e+00");
2305
2306	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2307	ASSERT_STREQ_LEN(written, buff, "1.6e+00");
2308
2309	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2310	ASSERT_STREQ_LEN(written, buff, "1.3e+00");
2311
2312	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2313	ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2314
2315	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2316	ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2317
2318	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2319	ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
2320
2321	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2322	ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2323
2324	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2325	ASSERT_STREQ_LEN(written, buff, "-1.7e+00");
2326
2327	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2328	ASSERT_STREQ_LEN(written, buff, "-1.4e+00");
2329
2330	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2331	ASSERT_STREQ_LEN(written, buff, "-1.9e+00");
2332	}
2333
2334	if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
2335	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.75);
2336	ASSERT_STREQ_LEN(written, buff, "1.7e+00");
2337
2338	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.25);
2339	ASSERT_STREQ_LEN(written, buff, "1.2e+00");
2340
2341	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.125);
2342	ASSERT_STREQ_LEN(written, buff, "1.1e+00");
2343
2344	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.625);
2345	ASSERT_STREQ_LEN(written, buff, "1.6e+00");
2346
2347	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.375);
2348	ASSERT_STREQ_LEN(written, buff, "1.3e+00");
2349
2350	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", 1.875);
2351	ASSERT_STREQ_LEN(written, buff, "1.8e+00");
2352
2353	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.75);
2354	ASSERT_STREQ_LEN(written, buff, "-1.7e+00");
2355
2356	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.25);
2357	ASSERT_STREQ_LEN(written, buff, "-1.2e+00");
2358
2359	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.125);
2360	ASSERT_STREQ_LEN(written, buff, "-1.1e+00");
2361
2362	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.625);
2363	ASSERT_STREQ_LEN(written, buff, "-1.6e+00");
2364
2365	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.375);
2366	ASSERT_STREQ_LEN(written, buff, "-1.3e+00");
2367
2368	written = LIBC_NAMESPACE::sprintf(buff, "%.1e", -1.875);
2369	ASSERT_STREQ_LEN(written, buff, "-1.8e+00");
2370	}
2371
2372	// Flag Tests.
2373	written = LIBC_NAMESPACE::sprintf(buff, "%+e", 1.0);
2374	ASSERT_STREQ_LEN(written, buff, "+1.000000e+00");
2375
2376	written = LIBC_NAMESPACE::sprintf(buff, "%+e", -1.0);
2377	ASSERT_STREQ_LEN(written, buff, "-1.000000e+00");
2378
2379	written = LIBC_NAMESPACE::sprintf(buff, "% e", 1.0);
2380	ASSERT_STREQ_LEN(written, buff, " 1.000000e+00");
2381
2382	written = LIBC_NAMESPACE::sprintf(buff, "% e", -1.0);
2383	ASSERT_STREQ_LEN(written, buff, "-1.000000e+00");
2384
2385	written = LIBC_NAMESPACE::sprintf(buff, "%-15e", 1.5);
2386	ASSERT_STREQ_LEN(written, buff, "1.500000e+00 ");
2387
2388	written = LIBC_NAMESPACE::sprintf(buff, "%#.e", 1.0);
2389	ASSERT_STREQ_LEN(written, buff, "1.e+00");
2390
2391	written = LIBC_NAMESPACE::sprintf(buff, "%#.0e", 1.5);
2392	ASSERT_STREQ_LEN(written, buff, "2.e+00");
2393
2394	written = LIBC_NAMESPACE::sprintf(buff, "%015e", 1.5);
2395	ASSERT_STREQ_LEN(written, buff, "0001.500000e+00");
2396
2397	written = LIBC_NAMESPACE::sprintf(buff, "%015e", -1.5);
2398	ASSERT_STREQ_LEN(written, buff, "-001.500000e+00");
2399
2400	written = LIBC_NAMESPACE::sprintf(buff, "%+- #0e", 0.0);
2401	ASSERT_STREQ_LEN(written, buff, "+0.000000e+00");
2402
2403	// Combined Tests.
2404
2405	written = LIBC_NAMESPACE::sprintf(buff, "%10.2e", 9.99);
2406	ASSERT_STREQ_LEN(written, buff, " 9.99e+00");
2407
2408	written = LIBC_NAMESPACE::sprintf(buff, "%10.1e", 9.99);
2409	ASSERT_STREQ_LEN(written, buff, " 1.0e+01");
2410
2411	written = LIBC_NAMESPACE::sprintf(buff, "%10.0e", 9.99);
2412	ASSERT_STREQ_LEN(written, buff, " 1e+01");
2413
2414	written = LIBC_NAMESPACE::sprintf(buff, "%10.0e", 0.0999);
2415	ASSERT_STREQ_LEN(written, buff, " 1e-01");
2416
2417	written = LIBC_NAMESPACE::sprintf(buff, "%-10.2e", 9.99);
2418	ASSERT_STREQ_LEN(written, buff, "9.99e+00 ");
2419
2420	written = LIBC_NAMESPACE::sprintf(buff, "%-10.1e", 9.99);
2421	ASSERT_STREQ_LEN(written, buff, "1.0e+01 ");
2422
2423	written = LIBC_NAMESPACE::sprintf(buff, "%-10.1e", 1.0e-50);
2424	ASSERT_STREQ_LEN(written, buff, "1.0e-50 ");
2425
2426	written = LIBC_NAMESPACE::sprintf(buff, "%30e", 1234567890123456789.0);
2427	ASSERT_STREQ_LEN(written, buff, " 1.234568e+18");
2428
2429	written = LIBC_NAMESPACE::sprintf(buff, "%-30e", 1234567890123456789.0);
2430	ASSERT_STREQ_LEN(written, buff, "1.234568e+18 ");
2431
2432	written = LIBC_NAMESPACE::sprintf(buff, "%25.14e", 9999999999999.99);
2433	ASSERT_STREQ_LEN(written, buff, " 9.99999999999999e+12");
2434
2435	written = LIBC_NAMESPACE::sprintf(buff, "%25.13e", 9999999999999.99);
2436	ASSERT_STREQ_LEN(written, buff, " 1.0000000000000e+13");
2437
2438	written = LIBC_NAMESPACE::sprintf(buff, "%25.12e", 9999999999999.99);
2439	ASSERT_STREQ_LEN(written, buff, " 1.000000000000e+13");
2440
2441	written = LIBC_NAMESPACE::sprintf(buff, "%12.3e %-12.3e", 0.1, 256.0);
2442	ASSERT_STREQ_LEN(written, buff, " 1.000e-01 2.560e+02 ");
2443
2444	written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3e % 012.3e", 0.1256, 1256.0);
2445	ASSERT_STREQ_LEN(written, buff, "+1.256e-01 001.256e+03");
2446	}
2447
2448	TEST(LlvmLibcSPrintfTest, FloatExponentLongDoubleConv) {
2449	char buff[1000];
2450	int written;
2451
2452	ForceRoundingMode r(RoundingMode::Nearest);
2453	// Length Modifier Tests.
2454
2455	written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.1L);
2456	ASSERT_STREQ_LEN(written, buff, "1.000000001e+18");
2457
2458	written = LIBC_NAMESPACE::sprintf(buff, "%.9Le", 1000000000500000000.0L);
2459	ASSERT_STREQ_LEN(written, buff, "1.000000000e+18");
2460
2461	written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1e100L);
2462	ASSERT_STREQ_LEN(written, buff, "1.000000e+100");
2463
2464	written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1.0L);
2465	ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
2466
2467	#if !defined(LIBC_TYPES_LONG_DOUBLE_IS_DOUBLE)
2468	written = LIBC_NAMESPACE::sprintf(buff, "%Le", 0xf.fffffffffffffffp+16380L);
2469	ASSERT_STREQ_LEN(written, buff, "1.189731e+4932");
2470
2471	written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1e1000L);
2472	ASSERT_STREQ_LEN(written, buff, "1.000000e+1000");
2473
2474	written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1e4900L);
2475	ASSERT_STREQ_LEN(written, buff, "1.000000e+4900");
2476
2477	written = LIBC_NAMESPACE::sprintf(buff, "%Le", 1.2345678e4900L);
2478	ASSERT_STREQ_LEN(written, buff, "1.234568e+4900");
2479	#endif
2480	}
2481
2482	TEST(LlvmLibcSPrintfTest, FloatAutoConv) {
2483	char buff[1000];
2484	int written;
2485
2486	ForceRoundingMode r(RoundingMode::Nearest);
2487	double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
2488	double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
2489
2490	written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0);
2491	ASSERT_STREQ_LEN(written, buff, "1");
2492
2493	written = LIBC_NAMESPACE::sprintf(buff, "%G", -1.0);
2494	ASSERT_STREQ_LEN(written, buff, "-1");
2495
2496	written = LIBC_NAMESPACE::sprintf(buff, "%g", -1.234567);
2497	ASSERT_STREQ_LEN(written, buff, "-1.23457");
2498
2499	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0);
2500	ASSERT_STREQ_LEN(written, buff, "0");
2501
2502	written = LIBC_NAMESPACE::sprintf(buff, "%g", -0.0);
2503	ASSERT_STREQ_LEN(written, buff, "-0");
2504
2505	written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.5);
2506	ASSERT_STREQ_LEN(written, buff, "1.5");
2507
2508	written = LIBC_NAMESPACE::sprintf(buff, "%g", 1e300);
2509	ASSERT_STREQ_LEN(written, buff, "1e+300");
2510
2511	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.1);
2512	ASSERT_STREQ_LEN(written, buff, "0.1");
2513
2514	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.001);
2515	ASSERT_STREQ_LEN(written, buff, "0.001");
2516
2517	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.00001);
2518	ASSERT_STREQ_LEN(written, buff, "1e-05");
2519
2520	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.0000001);
2521	ASSERT_STREQ_LEN(written, buff, "1e-07");
2522
2523	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0.000000001);
2524	ASSERT_STREQ_LEN(written, buff, "1e-09");
2525
2526	written = LIBC_NAMESPACE::sprintf(buff, "%g", 1.0e-20);
2527	ASSERT_STREQ_LEN(written, buff, "1e-20");
2528
2529	written = LIBC_NAMESPACE::sprintf(buff, "%g", 1234567890123456789.0);
2530	ASSERT_STREQ_LEN(written, buff, "1.23457e+18");
2531
2532	written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999990000000.00);
2533	ASSERT_STREQ_LEN(written, buff, "9.99999e+12");
2534
2535	written = LIBC_NAMESPACE::sprintf(buff, "%g", 9999999000000.00);
2536	ASSERT_STREQ_LEN(written, buff, "1e+13");
2537
2538	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0xa.aaaaaaaaaaaaaabp-7);
2539	ASSERT_STREQ_LEN(written, buff, "0.0833333");
2540
2541	// Simple Subnormal Tests.
2542
2543	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1027);
2544	ASSERT_STREQ_LEN(written, buff, "6.95336e-310");
2545
2546	written = LIBC_NAMESPACE::sprintf(buff, "%g", 0x1.0p-1074);
2547	ASSERT_STREQ_LEN(written, buff, "4.94066e-324");
2548
2549	// Inf/Nan Tests.
2550
2551	written = LIBC_NAMESPACE::sprintf(buff, "%g", inf);
2552	ASSERT_STREQ_LEN(written, buff, "inf");
2553
2554	written = LIBC_NAMESPACE::sprintf(buff, "%G", -inf);
2555	ASSERT_STREQ_LEN(written, buff, "-INF");
2556
2557	written = LIBC_NAMESPACE::sprintf(buff, "%g", nan);
2558	ASSERT_STREQ_LEN(written, buff, "nan");
2559
2560	written = LIBC_NAMESPACE::sprintf(buff, "%G", -nan);
2561	ASSERT_STREQ_LEN(written, buff, "-NAN");
2562
2563	// Min Width Tests.
2564
2565	written = LIBC_NAMESPACE::sprintf(buff, "%15g", 1.0);
2566	ASSERT_STREQ_LEN(written, buff, " 1");
2567
2568	written = LIBC_NAMESPACE::sprintf(buff, "%15g", -1.0);
2569	ASSERT_STREQ_LEN(written, buff, " -1");
2570
2571	written = LIBC_NAMESPACE::sprintf(buff, "%15g", 1.0e5);
2572	ASSERT_STREQ_LEN(written, buff, " 100000");
2573
2574	written = LIBC_NAMESPACE::sprintf(buff, "%15g", -1.0e5);
2575	ASSERT_STREQ_LEN(written, buff, " -100000");
2576
2577	written = LIBC_NAMESPACE::sprintf(buff, "%10g", 1.0e-5);
2578	ASSERT_STREQ_LEN(written, buff, " 1e-05");
2579
2580	// Precision Tests.
2581
2582	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.23456789);
2583	ASSERT_STREQ_LEN(written, buff, "1.2");
2584
2585	// Trimming trailing zeroes causes the precision to be ignored here.
2586	written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 0.0);
2587	ASSERT_STREQ_LEN(written, buff, "0");
2588
2589	written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 0.0);
2590	ASSERT_STREQ_LEN(written, buff, "0");
2591
2592	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 0.1);
2593	ASSERT_STREQ_LEN(written, buff, "0.1");
2594
2595	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.09);
2596	ASSERT_STREQ_LEN(written, buff, "1.1");
2597
2598	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.04);
2599	ASSERT_STREQ_LEN(written, buff, "1");
2600
2601	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.19);
2602	ASSERT_STREQ_LEN(written, buff, "1.2");
2603
2604	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.99);
2605	ASSERT_STREQ_LEN(written, buff, "2");
2606
2607	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 9.99);
2608	ASSERT_STREQ_LEN(written, buff, "10");
2609
2610	written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 99.9);
2611	ASSERT_STREQ_LEN(written, buff, "99.9");
2612
2613	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 99.9);
2614	ASSERT_STREQ_LEN(written, buff, "1e+02");
2615
2616	written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 99.9);
2617	ASSERT_STREQ_LEN(written, buff, "1e+02");
2618
2619	written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 1.25);
2620	ASSERT_STREQ_LEN(written, buff, "1.25");
2621
2622	written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 1.25);
2623	ASSERT_STREQ_LEN(written, buff, "1");
2624
2625	written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 1.75);
2626	ASSERT_STREQ_LEN(written, buff, "2");
2627
2628	written = LIBC_NAMESPACE::sprintf(buff, "%.20g", 1.234e-10);
2629	ASSERT_STREQ_LEN(written, buff, "1.2340000000000000814e-10");
2630
2631	written = LIBC_NAMESPACE::sprintf(buff, "%.3g", -9.99);
2632	ASSERT_STREQ_LEN(written, buff, "-9.99");
2633
2634	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -9.99);
2635	ASSERT_STREQ_LEN(written, buff, "-10");
2636
2637	written = LIBC_NAMESPACE::sprintf(buff, "%.1g", -9.99);
2638	ASSERT_STREQ_LEN(written, buff, "-1e+01");
2639
2640	written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 1.008);
2641	ASSERT_STREQ_LEN(written, buff, "1.008");
2642
2643	written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 1.008e3);
2644	ASSERT_STREQ_LEN(written, buff, "1008");
2645
2646	written = LIBC_NAMESPACE::sprintf(buff, "%.4g", 9999.0);
2647	ASSERT_STREQ_LEN(written, buff, "9999");
2648
2649	written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 9999.0);
2650	ASSERT_STREQ_LEN(written, buff, "1e+04");
2651
2652	written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 1256.0);
2653	ASSERT_STREQ_LEN(written, buff, "1.26e+03");
2654
2655	// Found through large scale testing.
2656	written = LIBC_NAMESPACE::sprintf(buff, "%.15g", 22.25);
2657	ASSERT_STREQ_LEN(written, buff, "22.25");
2658
2659	// These tests also focus on rounding, but only in how it relates to the base
2660	// 10 exponent. The %g conversion selects between being a %f or %e conversion
2661	// based on what the exponent would be if it was %e. If we call the precision
2662	// P (equal to 6 if the precision is not set, 0 if the provided precision is
2663	// 0, and provided precision - 1 otherwise) and the exponent X, then the style
2664	// is %f with an effective precision of P - X + 1 if P > X >= -4, else the
2665	// style is %e with effective precision P - 1. Additionally, it attempts to
2666	// trim zeros that would be displayed after the decimal point.
2667	written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 9.059E+200);
2668	ASSERT_STREQ_LEN(written, buff, "9e+200");
2669
2670	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 9.059E+200);
2671	ASSERT_STREQ_LEN(written, buff, "9.1e+200");
2672
2673	// For this test, P = 0 and X = 1, so P > X >= -4 is false, giving a %e style.
2674	written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 9.5);
2675	ASSERT_STREQ_LEN(written, buff, "1e+01");
2676
2677	// Subnormal Precision Tests
2678	#ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2679	written = LIBC_NAMESPACE::sprintf(buff, "%.310g", 0x1.0p-1022);
2680	ASSERT_STREQ_LEN(
2681	written, buff,
2682	"2."
2683	"225073858507201383090232717332404064219215980462331830553327416887204434"
2684	"813918195854283159012511020564067339731035811005152434161553460108856012"
2685	"385377718821130777993532002330479610147442583636071921565046942503734208"
2686	"375250806650616658158948720491179968591639648500635908770118304874799780"
2687	"887753749949451580452e-308");
2688	#endif
2689
2690	written = LIBC_NAMESPACE::sprintf(buff, "%.30g", 0x1.0p-1022);
2691	ASSERT_STREQ_LEN(written, buff, "2.22507385850720138309023271733e-308");
2692
2693	#ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2694	written = LIBC_NAMESPACE::sprintf(buff, "%.310g", 0x1.0p-1023);
2695	ASSERT_STREQ_LEN(
2696	written, buff,
2697	"1."
2698	"112536929253600691545116358666202032109607990231165915276663708443602217"
2699	"406959097927141579506255510282033669865517905502576217080776730054428006"
2700	"192688859410565388996766001165239805073721291818035960782523471251867104"
2701	"187625403325308329079474360245589984295819824250317954385059152437399890"
2702	"443876874974725790226e-308");
2703	#endif
2704
2705	written = LIBC_NAMESPACE::sprintf(buff, "%.7g", 9.99999e-310);
2706	ASSERT_STREQ_LEN(written, buff, "9.99999e-310");
2707
2708	written = LIBC_NAMESPACE::sprintf(buff, "%.6g", 9.99999e-310);
2709	ASSERT_STREQ_LEN(written, buff, "9.99999e-310");
2710
2711	written = LIBC_NAMESPACE::sprintf(buff, "%.5g", 9.99999e-310);
2712	ASSERT_STREQ_LEN(written, buff, "1e-309");
2713
2714	written = LIBC_NAMESPACE::sprintf(buff, "%.4g", 9.99999e-310);
2715	ASSERT_STREQ_LEN(written, buff, "1e-309");
2716
2717	written = LIBC_NAMESPACE::sprintf(buff, "%.3g", 9.99999e-310);
2718	ASSERT_STREQ_LEN(written, buff, "1e-309");
2719
2720	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 9.99999e-310);
2721	ASSERT_STREQ_LEN(written, buff, "1e-309");
2722
2723	written = LIBC_NAMESPACE::sprintf(buff, "%.1g", 9.99999e-310);
2724	ASSERT_STREQ_LEN(written, buff, "1e-309");
2725
2726	written = LIBC_NAMESPACE::sprintf(buff, "%.0g", 9.99999e-310);
2727	ASSERT_STREQ_LEN(written, buff, "1e-309");
2728
2729	written = LIBC_NAMESPACE::sprintf(buff, "%.10g", 0x1.0p-1074);
2730	ASSERT_STREQ_LEN(written, buff, "4.940656458e-324");
2731
2732	// Rounding Mode Tests.
2733
2734	if (ForceRoundingMode r(RoundingMode::Nearest); r.success) {
2735	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2736	ASSERT_STREQ_LEN(written, buff, "1.8");
2737
2738	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2739	ASSERT_STREQ_LEN(written, buff, "1.2");
2740
2741	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2742	ASSERT_STREQ_LEN(written, buff, "1.1");
2743
2744	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2745	ASSERT_STREQ_LEN(written, buff, "1.6");
2746
2747	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2748	ASSERT_STREQ_LEN(written, buff, "1.4");
2749
2750	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2751	ASSERT_STREQ_LEN(written, buff, "1.9");
2752
2753	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2754	ASSERT_STREQ_LEN(written, buff, "-1.8");
2755
2756	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2757	ASSERT_STREQ_LEN(written, buff, "-1.2");
2758
2759	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2760	ASSERT_STREQ_LEN(written, buff, "-1.1");
2761
2762	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2763	ASSERT_STREQ_LEN(written, buff, "-1.6");
2764
2765	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2766	ASSERT_STREQ_LEN(written, buff, "-1.4");
2767
2768	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2769	ASSERT_STREQ_LEN(written, buff, "-1.9");
2770	}
2771
2772	if (ForceRoundingMode r(RoundingMode::Upward); r.success) {
2773	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2774	ASSERT_STREQ_LEN(written, buff, "1.8");
2775
2776	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2777	ASSERT_STREQ_LEN(written, buff, "1.3");
2778
2779	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2780	ASSERT_STREQ_LEN(written, buff, "1.2");
2781
2782	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2783	ASSERT_STREQ_LEN(written, buff, "1.7");
2784
2785	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2786	ASSERT_STREQ_LEN(written, buff, "1.4");
2787
2788	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2789	ASSERT_STREQ_LEN(written, buff, "1.9");
2790
2791	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2792	ASSERT_STREQ_LEN(written, buff, "-1.7");
2793
2794	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2795	ASSERT_STREQ_LEN(written, buff, "-1.2");
2796
2797	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2798	ASSERT_STREQ_LEN(written, buff, "-1.1");
2799
2800	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2801	ASSERT_STREQ_LEN(written, buff, "-1.6");
2802
2803	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2804	ASSERT_STREQ_LEN(written, buff, "-1.3");
2805
2806	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2807	ASSERT_STREQ_LEN(written, buff, "-1.8");
2808	}
2809
2810	if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
2811	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2812	ASSERT_STREQ_LEN(written, buff, "1.7");
2813
2814	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2815	ASSERT_STREQ_LEN(written, buff, "1.2");
2816
2817	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2818	ASSERT_STREQ_LEN(written, buff, "1.1");
2819
2820	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2821	ASSERT_STREQ_LEN(written, buff, "1.6");
2822
2823	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2824	ASSERT_STREQ_LEN(written, buff, "1.3");
2825
2826	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2827	ASSERT_STREQ_LEN(written, buff, "1.8");
2828
2829	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2830	ASSERT_STREQ_LEN(written, buff, "-1.8");
2831
2832	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2833	ASSERT_STREQ_LEN(written, buff, "-1.3");
2834
2835	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2836	ASSERT_STREQ_LEN(written, buff, "-1.2");
2837
2838	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2839	ASSERT_STREQ_LEN(written, buff, "-1.7");
2840
2841	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2842	ASSERT_STREQ_LEN(written, buff, "-1.4");
2843
2844	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2845	ASSERT_STREQ_LEN(written, buff, "-1.9");
2846	}
2847
2848	if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
2849	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.75);
2850	ASSERT_STREQ_LEN(written, buff, "1.7");
2851
2852	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.25);
2853	ASSERT_STREQ_LEN(written, buff, "1.2");
2854
2855	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.125);
2856	ASSERT_STREQ_LEN(written, buff, "1.1");
2857
2858	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.625);
2859	ASSERT_STREQ_LEN(written, buff, "1.6");
2860
2861	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.375);
2862	ASSERT_STREQ_LEN(written, buff, "1.3");
2863
2864	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", 1.875);
2865	ASSERT_STREQ_LEN(written, buff, "1.8");
2866
2867	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.75);
2868	ASSERT_STREQ_LEN(written, buff, "-1.7");
2869
2870	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.25);
2871	ASSERT_STREQ_LEN(written, buff, "-1.2");
2872
2873	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.125);
2874	ASSERT_STREQ_LEN(written, buff, "-1.1");
2875
2876	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.625);
2877	ASSERT_STREQ_LEN(written, buff, "-1.6");
2878
2879	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.375);
2880	ASSERT_STREQ_LEN(written, buff, "-1.3");
2881
2882	written = LIBC_NAMESPACE::sprintf(buff, "%.2g", -1.875);
2883	ASSERT_STREQ_LEN(written, buff, "-1.8");
2884	}
2885
2886	// Flag Tests.
2887	written = LIBC_NAMESPACE::sprintf(buff, "%+g", 1.0);
2888	ASSERT_STREQ_LEN(written, buff, "+1");
2889
2890	written = LIBC_NAMESPACE::sprintf(buff, "%+g", -1.0);
2891	ASSERT_STREQ_LEN(written, buff, "-1");
2892
2893	written = LIBC_NAMESPACE::sprintf(buff, "% g", 1.0);
2894	ASSERT_STREQ_LEN(written, buff, " 1");
2895
2896	written = LIBC_NAMESPACE::sprintf(buff, "% g", -1.0);
2897	ASSERT_STREQ_LEN(written, buff, "-1");
2898
2899	written = LIBC_NAMESPACE::sprintf(buff, "%-15g", 1.5);
2900	ASSERT_STREQ_LEN(written, buff, "1.5 ");
2901
2902	written = LIBC_NAMESPACE::sprintf(buff, "%#.g", 1.0);
2903	ASSERT_STREQ_LEN(written, buff, "1.");
2904
2905	written = LIBC_NAMESPACE::sprintf(buff, "%#g", 1.0);
2906	ASSERT_STREQ_LEN(written, buff, "1.00000");
2907
2908	written = LIBC_NAMESPACE::sprintf(buff, "%#.0g", 1.5);
2909	ASSERT_STREQ_LEN(written, buff, "2.");
2910
2911	written = LIBC_NAMESPACE::sprintf(buff, "%015g", 1.5);
2912	ASSERT_STREQ_LEN(written, buff, "0000000000001.5");
2913
2914	written = LIBC_NAMESPACE::sprintf(buff, "%015g", -1.5);
2915	ASSERT_STREQ_LEN(written, buff, "-000000000001.5");
2916
2917	written = LIBC_NAMESPACE::sprintf(buff, "%+- #0g", 0.0);
2918	ASSERT_STREQ_LEN(written, buff, "+0.00000");
2919
2920	// Combined Tests.
2921
2922	written = LIBC_NAMESPACE::sprintf(buff, "%10.3g", 9.99);
2923	ASSERT_STREQ_LEN(written, buff, " 9.99");
2924
2925	written = LIBC_NAMESPACE::sprintf(buff, "%10.2g", 9.99);
2926	ASSERT_STREQ_LEN(written, buff, " 10");
2927
2928	written = LIBC_NAMESPACE::sprintf(buff, "%10.1g", 9.99);
2929	ASSERT_STREQ_LEN(written, buff, " 1e+01");
2930
2931	written = LIBC_NAMESPACE::sprintf(buff, "%-10.3g", 9.99);
2932	ASSERT_STREQ_LEN(written, buff, "9.99 ");
2933
2934	written = LIBC_NAMESPACE::sprintf(buff, "%-10.2g", 9.99);
2935	ASSERT_STREQ_LEN(written, buff, "10 ");
2936
2937	written = LIBC_NAMESPACE::sprintf(buff, "%-10.1g", 9.99);
2938	ASSERT_STREQ_LEN(written, buff, "1e+01 ");
2939
2940	written = LIBC_NAMESPACE::sprintf(buff, "%-10.1g", 1.0e-50);
2941	ASSERT_STREQ_LEN(written, buff, "1e-50 ");
2942
2943	written = LIBC_NAMESPACE::sprintf(buff, "%30g", 1234567890123456789.0);
2944	ASSERT_STREQ_LEN(written, buff, " 1.23457e+18");
2945
2946	written = LIBC_NAMESPACE::sprintf(buff, "%-30g", 1234567890123456789.0);
2947	ASSERT_STREQ_LEN(written, buff, "1.23457e+18 ");
2948
2949	written = LIBC_NAMESPACE::sprintf(buff, "%25.15g", 9999999999999.99);
2950	ASSERT_STREQ_LEN(written, buff, " 9999999999999.99");
2951
2952	written = LIBC_NAMESPACE::sprintf(buff, "%25.14g", 9999999999999.99);
2953	ASSERT_STREQ_LEN(written, buff, " 10000000000000");
2954
2955	written = LIBC_NAMESPACE::sprintf(buff, "%25.13g", 9999999999999.99);
2956	ASSERT_STREQ_LEN(written, buff, " 1e+13");
2957
2958	written = LIBC_NAMESPACE::sprintf(buff, "%#12.3g %-12.3g", 0.1, 256.0);
2959	ASSERT_STREQ_LEN(written, buff, " 0.100 256 ");
2960
2961	written = LIBC_NAMESPACE::sprintf(buff, "%+-#12.3g % 012.3g", 0.1256, 1256.0);
2962	ASSERT_STREQ_LEN(written, buff, "+0.126 0001.26e+03");
2963	}
2964
2965	TEST(LlvmLibcSPrintfTest, FloatAutoLongDoubleConv) {
2966	char buff[1000];
2967	int written;
2968
2969	ForceRoundingMode r(RoundingMode::Nearest);
2970
2971	// Length Modifier Tests.
2972
2973	// TODO: Tests for other long double types
2974	#if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
2975
2976	written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xf.fffffffffffffffp+16380L);
2977	ASSERT_STREQ_LEN(written, buff, "1.18973e+4932");
2978
2979	written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0xa.aaaaaaaaaaaaaabp-7L);
2980	ASSERT_STREQ_LEN(written, buff, "0.0833333");
2981
2982	#ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
2983	written = LIBC_NAMESPACE::sprintf(buff, "%.60Lg", 0xa.aaaaaaaaaaaaaabp-7L);
2984	ASSERT_STREQ_LEN(
2985	written, buff,
2986	"0.0833333333333333333355920878593448009041821933351457118988037");
2987	#endif
2988
2989	#endif // LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80
2990
2991	written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 9.99999999999e-100L);
2992	ASSERT_STREQ_LEN(written, buff, "1e-99");
2993
2994	written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 1e100L);
2995	ASSERT_STREQ_LEN(written, buff, "1e+100");
2996
2997	written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 1.0L);
2998	ASSERT_STREQ_LEN(written, buff, "1");
2999
3000	written = LIBC_NAMESPACE::sprintf(buff, "%Lg", 0.1L);
3001	ASSERT_STREQ_LEN(written, buff, "0.1");
3002
3003	char big_buff[10000];
3004	written = LIBC_NAMESPACE::sprintf(big_buff, "%Lg", 1e1000L);
3005	ASSERT_STREQ_LEN(written, big_buff, "1e+1000");
3006
3007	written = LIBC_NAMESPACE::sprintf(big_buff, "%Lg", 1e4900L);
3008	ASSERT_STREQ_LEN(written, big_buff, "1e+4900");
3009	}
3010
3011	#endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
3012
3013	#if defined(LIBC_COMPILER_HAS_FIXED_POINT) && \
3014	!defined(LIBC_COPT_PRINTF_DISABLE_FIXED_POINT)
3015	TEST(LlvmLibcSPrintfTest, FixedConv) {
3016	char buff[1000];
3017	int written;
3018
3019	// These numeric tests are potentially a little weak, but the fuzz test is
3020	// more thorough than my handwritten tests tend to be.
3021
3022	// TODO: Replace hex literals with their appropriate fixed point literals.
3023
3024	written = LIBC_NAMESPACE::sprintf(buff, "%k", 0x0); // 0.0
3025	ASSERT_STREQ_LEN(written, buff, "0.000000");
3026
3027	written = LIBC_NAMESPACE::sprintf(buff, "%k", 0x80000000); // -0.0
3028	ASSERT_STREQ_LEN(written, buff, "-0.000000");
3029
3030	written = LIBC_NAMESPACE::sprintf(buff, "%r", 0xffff); // -fract max
3031	ASSERT_STREQ_LEN(written, buff, "-0.999969");
3032
3033	written = LIBC_NAMESPACE::sprintf(buff, "%R", 0xffff); // unsigned fract max
3034	ASSERT_STREQ_LEN(written, buff, "0.999985");
3035
3036	written = LIBC_NAMESPACE::sprintf(buff, "%k", 0xffffffff); // -accum max
3037	ASSERT_STREQ_LEN(written, buff, "-65535.999969");
3038
3039	written =
3040	LIBC_NAMESPACE::sprintf(buff, "%K", 0xffffffff); // unsigned accum max
3041	ASSERT_STREQ_LEN(written, buff, "65535.999985");
3042
3043	written = LIBC_NAMESPACE::sprintf(buff, "%r", 0x7fff); // fract max
3044	ASSERT_STREQ_LEN(written, buff, "0.999969");
3045
3046	written = LIBC_NAMESPACE::sprintf(buff, "%k", 0x7fffffff); // accum max
3047	ASSERT_STREQ_LEN(written, buff, "65535.999969");
3048
3049	// Length Modifier Tests.
3050
3051	written = LIBC_NAMESPACE::sprintf(buff, "%hk", 0x0); // 0.0
3052	ASSERT_STREQ_LEN(written, buff, "0.000000");
3053
3054	written = LIBC_NAMESPACE::sprintf(buff, "%hk", 0xffff); // -short accum max
3055	ASSERT_STREQ_LEN(written, buff, "-255.992188");
3056
3057	written = LIBC_NAMESPACE::sprintf(buff, "%hr", 0x0); // 0.0
3058	ASSERT_STREQ_LEN(written, buff, "0.000000");
3059
3060	written = LIBC_NAMESPACE::sprintf(buff, "%hr", 0xff); // -short fract max
3061	ASSERT_STREQ_LEN(written, buff, "-0.992188");
3062
3063	written = LIBC_NAMESPACE::sprintf(buff, "%hK", 0x0); // 0.0
3064	ASSERT_STREQ_LEN(written, buff, "0.000000");
3065
3066	written =
3067	LIBC_NAMESPACE::sprintf(buff, "%hK", 0xffff); // unsigned short accum max
3068	ASSERT_STREQ_LEN(written, buff, "255.996094");
3069
3070	written = LIBC_NAMESPACE::sprintf(buff, "%hR", 0x0); // 0.0
3071	ASSERT_STREQ_LEN(written, buff, "0.000000");
3072
3073	written =
3074	LIBC_NAMESPACE::sprintf(buff, "%hR", 0xff); // unsigned short fract max
3075	ASSERT_STREQ_LEN(written, buff, "0.996094");
3076
3077	written = LIBC_NAMESPACE::sprintf(buff, "%lk", 0x0ll); // 0.0
3078	ASSERT_STREQ_LEN(written, buff, "0.000000");
3079
3080	written = LIBC_NAMESPACE::sprintf(buff, "%lk",
3081	0xffffffffffffffff); //-long accum max
3082	ASSERT_STREQ_LEN(written, buff, "-4294967296.000000");
3083
3084	written = LIBC_NAMESPACE::sprintf(buff, "%lr", 0x0); // 0.0
3085	ASSERT_STREQ_LEN(written, buff, "0.000000");
3086
3087	written = LIBC_NAMESPACE::sprintf(buff, "%lr",
3088	0xffffffff); //-long fract max
3089	ASSERT_STREQ_LEN(written, buff, "-1.000000");
3090
3091	written = LIBC_NAMESPACE::sprintf(buff, "%lK", 0x0ll); // 0.0
3092	ASSERT_STREQ_LEN(written, buff, "0.000000");
3093
3094	written =
3095	LIBC_NAMESPACE::sprintf(buff, "%lK",
3096	0xffffffffffffffff); // unsigned long accum max
3097	ASSERT_STREQ_LEN(written, buff, "4294967296.000000");
3098
3099	written = LIBC_NAMESPACE::sprintf(buff, "%lR", 0x0); // 0.0
3100	ASSERT_STREQ_LEN(written, buff, "0.000000");
3101
3102	written = LIBC_NAMESPACE::sprintf(buff, "%lR",
3103	0xffffffff); // unsigned long fract max
3104	ASSERT_STREQ_LEN(written, buff, "1.000000");
3105
3106	// Min Width Tests.
3107
3108	written = LIBC_NAMESPACE::sprintf(buff, "%10k", 0x0000a000); // 1.25
3109	ASSERT_STREQ_LEN(written, buff, " 1.250000");
3110
3111	written = LIBC_NAMESPACE::sprintf(buff, "%10k", 0x8000a000); //-1.25
3112	ASSERT_STREQ_LEN(written, buff, " -1.250000");
3113
3114	written = LIBC_NAMESPACE::sprintf(buff, "%8k", 0x0000a000); // 1.25
3115	ASSERT_STREQ_LEN(written, buff, "1.250000");
3116
3117	written = LIBC_NAMESPACE::sprintf(buff, "%9k", 0x8000a000); //-1.25
3118	ASSERT_STREQ_LEN(written, buff, "-1.250000");
3119
3120	written = LIBC_NAMESPACE::sprintf(buff, "%4k", 0x0000a000); // 1.25
3121	ASSERT_STREQ_LEN(written, buff, "1.250000");
3122
3123	written = LIBC_NAMESPACE::sprintf(buff, "%4k", 0x8000a000); //-1.25
3124	ASSERT_STREQ_LEN(written, buff, "-1.250000");
3125
3126	// Precision Tests.
3127
3128	written =
3129	LIBC_NAMESPACE::sprintf(buff, "%.16K", 0xFFFFFFFF); // unsigned accum max
3130	ASSERT_STREQ_LEN(written, buff, "65535.9999847412109375");
3131
3132	written = LIBC_NAMESPACE::sprintf(
3133	buff, "%.32lK", 0xFFFFFFFFFFFFFFFF); // unsigned long accum max
3134	ASSERT_STREQ_LEN(written, buff,
3135	"4294967295.99999999976716935634613037109375");
3136
3137	written =
3138	LIBC_NAMESPACE::sprintf(buff, "%.0K", 0xFFFFFFFF); // unsigned accum max
3139	ASSERT_STREQ_LEN(written, buff, "65536");
3140
3141	written = LIBC_NAMESPACE::sprintf(buff, "%.0R", 0xFFFF); // unsigned fract max
3142	ASSERT_STREQ_LEN(written, buff, "1");
3143
3144	// Flag Tests.
3145
3146	written = LIBC_NAMESPACE::sprintf(buff, "%+k", 0x0000a000); // 1.25
3147	ASSERT_STREQ_LEN(written, buff, "+1.250000");
3148
3149	written = LIBC_NAMESPACE::sprintf(buff, "%+k", 0x8000a000); //-1.25
3150	ASSERT_STREQ_LEN(written, buff, "-1.250000");
3151
3152	written = LIBC_NAMESPACE::sprintf(buff, "% k", 0x0000a000); // 1.25
3153	ASSERT_STREQ_LEN(written, buff, " 1.250000");
3154
3155	written = LIBC_NAMESPACE::sprintf(buff, "% k", 0x8000a000); //-1.25
3156	ASSERT_STREQ_LEN(written, buff, "-1.250000");
3157
3158	// unsigned variants ignore sign flags.
3159	written = LIBC_NAMESPACE::sprintf(buff, "%+K", 0x00014000); // 1.25
3160	ASSERT_STREQ_LEN(written, buff, "1.250000");
3161
3162	written = LIBC_NAMESPACE::sprintf(buff, "% K", 0x00014000); // 1.25
3163	ASSERT_STREQ_LEN(written, buff, "1.250000");
3164
3165	written = LIBC_NAMESPACE::sprintf(buff, "%-10k", 0x0000c000); // 1.5
3166	ASSERT_STREQ_LEN(written, buff, "1.500000 ");
3167
3168	written = LIBC_NAMESPACE::sprintf(buff, "%#.k", 0x00008000); // 1.0
3169	ASSERT_STREQ_LEN(written, buff, "1.");
3170
3171	written = LIBC_NAMESPACE::sprintf(buff, "%#.0k", 0x0000c000); // 1.5
3172	ASSERT_STREQ_LEN(written, buff, "2.");
3173
3174	written = LIBC_NAMESPACE::sprintf(buff, "%010k", 0x0000c000); // 1.5
3175	ASSERT_STREQ_LEN(written, buff, "001.500000");
3176
3177	written = LIBC_NAMESPACE::sprintf(buff, "%010k", 0x8000c000); //-1.5
3178	ASSERT_STREQ_LEN(written, buff, "-01.500000");
3179
3180	written = LIBC_NAMESPACE::sprintf(buff, "%+- #0k", 0); // 0.0
3181	ASSERT_STREQ_LEN(written, buff, "+0.000000");
3182
3183	// Combined Tests.
3184
3185	written = LIBC_NAMESPACE::sprintf(buff, "%10.2k", 0x0004feb8); // 9.99
3186	ASSERT_STREQ_LEN(written, buff, " 9.99");
3187
3188	written = LIBC_NAMESPACE::sprintf(buff, "%5.1k", 0x0004feb8); // 9.99
3189	ASSERT_STREQ_LEN(written, buff, " 10.0");
3190
3191	written = LIBC_NAMESPACE::sprintf(buff, "%-10.2k", 0x0004feb8); // 9.99
3192	ASSERT_STREQ_LEN(written, buff, "9.99 ");
3193
3194	written = LIBC_NAMESPACE::sprintf(buff, "%-5.1k", 0x0004feb8); // 9.99
3195	ASSERT_STREQ_LEN(written, buff, "10.0 ");
3196
3197	written = LIBC_NAMESPACE::sprintf(buff, "%-5.1k", 0x00000001); // accum min
3198	ASSERT_STREQ_LEN(written, buff, "0.0 ");
3199
3200	written = LIBC_NAMESPACE::sprintf(buff, "%30k", 0x7fffffff); // accum max
3201	ASSERT_STREQ_LEN(written, buff, " 65535.999969");
3202
3203	written = LIBC_NAMESPACE::sprintf(buff, "%-30k", 0x7fffffff); // accum max
3204	ASSERT_STREQ_LEN(written, buff, "65535.999969 ");
3205
3206	written = LIBC_NAMESPACE::sprintf(buff, "%20.2lK",
3207	0x3b9ac9ffFD70A3D7); // 999999999.99
3208	ASSERT_STREQ_LEN(written, buff, " 999999999.99");
3209
3210	written = LIBC_NAMESPACE::sprintf(buff, "%20.1lK",
3211	0x3b9ac9ffFD70A3D7); // 999999999.99
3212	ASSERT_STREQ_LEN(written, buff, " 1000000000.0");
3213
3214	written = LIBC_NAMESPACE::sprintf(buff, "%12.3R %-12.3k", 0x1999,
3215	0x00800000); // 0.1, 256.0
3216	ASSERT_STREQ_LEN(written, buff, " 0.100 256.000 ");
3217
3218	written =
3219	LIBC_NAMESPACE::sprintf(buff, "%+-#12.3lk % 012.3k", 0x000000001013a92all,
3220	0x02740000); // 0.126, 1256.0
3221	ASSERT_STREQ_LEN(written, buff, "+0.126 0001256.000");
3222	}
3223	#endif // defined(LIBC_COMPILER_HAS_FIXED_POINT) &&
3224	// !defined(LIBC_COPT_PRINTF_DISABLE_FIXED_POINT)
3225
3226	#ifndef LIBC_COPT_PRINTF_DISABLE_STRERROR
3227	TEST(LlvmLibcSPrintfTest, StrerrorConv) {
3228	char buff[1000];
3229	int written;
3230
3231	libc_errno = 0;
3232	written = LIBC_NAMESPACE::sprintf(buff, "%m");
3233	ASSERT_STREQ_LEN(written, buff, "Success");
3234
3235	libc_errno = ERANGE;
3236	written = LIBC_NAMESPACE::sprintf(buff, "%m");
3237	ASSERT_STREQ_LEN(written, buff, "Numerical result out of range");
3238
3239	// Check that it correctly consumes no arguments.
3240	libc_errno = 0;
3241	written = LIBC_NAMESPACE::sprintf(buff, "%m %d", 1);
3242	ASSERT_STREQ_LEN(written, buff, "Success 1");
3243
3244	// Width Tests
3245
3246	libc_errno = 0;
3247	written = LIBC_NAMESPACE::sprintf(buff, "%10m");
3248	ASSERT_STREQ_LEN(written, buff, " Success");
3249
3250	libc_errno = ERANGE;
3251	written = LIBC_NAMESPACE::sprintf(buff, "%10m");
3252	ASSERT_STREQ_LEN(written, buff, "Numerical result out of range");
3253
3254	// Precision Tests
3255
3256	libc_errno = 0;
3257	written = LIBC_NAMESPACE::sprintf(buff, "%.10m");
3258	ASSERT_STREQ_LEN(written, buff, "Success");
3259
3260	libc_errno = ERANGE;
3261	written = LIBC_NAMESPACE::sprintf(buff, "%.10m");
3262	ASSERT_STREQ_LEN(written, buff, "Numerical ");
3263
3264	// Flag Tests (Only '-' since the others only affect ints)
3265
3266	libc_errno = 0;
3267	written = LIBC_NAMESPACE::sprintf(buff, "%-10m");
3268	ASSERT_STREQ_LEN(written, buff, "Success ");
3269
3270	libc_errno = ERANGE;
3271	written = LIBC_NAMESPACE::sprintf(buff, "%-10m");
3272	ASSERT_STREQ_LEN(written, buff, "Numerical result out of range");
3273
3274	// Alt Mode Tests
3275	// Since alt mode here is effectively a completely separate conversion, it
3276	// gets separate tests.
3277
3278	libc_errno = 0;
3279	written = LIBC_NAMESPACE::sprintf(buff, "%#m");
3280	ASSERT_STREQ_LEN(written, buff, "0");
3281
3282	libc_errno = ERANGE;
3283	written = LIBC_NAMESPACE::sprintf(buff, "%#m");
3284	ASSERT_STREQ_LEN(written, buff, "ERANGE");
3285
3286	libc_errno = -9999;
3287	written = LIBC_NAMESPACE::sprintf(buff, "%#m");
3288	ASSERT_STREQ_LEN(written, buff, "-9999");
3289
3290	// Alt Mode Width
3291
3292	libc_errno = 0;
3293	written = LIBC_NAMESPACE::sprintf(buff, "%#10m");
3294	ASSERT_STREQ_LEN(written, buff, " 0");
3295
3296	libc_errno = ERANGE;
3297	written = LIBC_NAMESPACE::sprintf(buff, "%#10m");
3298	ASSERT_STREQ_LEN(written, buff, " ERANGE");
3299
3300	libc_errno = -9999;
3301	written = LIBC_NAMESPACE::sprintf(buff, "%#10m");
3302	ASSERT_STREQ_LEN(written, buff, " -9999");
3303
3304	libc_errno = ERANGE;
3305	written = LIBC_NAMESPACE::sprintf(buff, "%#3m");
3306	ASSERT_STREQ_LEN(written, buff, "ERANGE");
3307
3308	libc_errno = -9999;
3309	written = LIBC_NAMESPACE::sprintf(buff, "%#3m");
3310	ASSERT_STREQ_LEN(written, buff, "-9999");
3311
3312	// Alt Mode Precision
3313
3314	libc_errno = ERANGE;
3315	written = LIBC_NAMESPACE::sprintf(buff, "%#.10m");
3316	ASSERT_STREQ_LEN(written, buff, "ERANGE");
3317
3318	libc_errno = -9999;
3319	written = LIBC_NAMESPACE::sprintf(buff, "%#.10m");
3320	ASSERT_STREQ_LEN(written, buff, "-0000009999");
3321
3322	libc_errno = ERANGE;
3323	written = LIBC_NAMESPACE::sprintf(buff, "%#.3m");
3324	ASSERT_STREQ_LEN(written, buff, "ERA");
3325
3326	libc_errno = -9999;
3327	written = LIBC_NAMESPACE::sprintf(buff, "%#.3m");
3328	ASSERT_STREQ_LEN(written, buff, "-9999");
3329
3330	// We don't test precision (or int flags) on errno = 0 because it behaves
3331	// weirdly, see the docs for more information.
3332	libc_errno = 0;
3333	written = LIBC_NAMESPACE::sprintf(buff, "%#.1m");
3334	ASSERT_STREQ_LEN(written, buff, "0");
3335
3336	// Alt Mode Flags
3337
3338	// '-' flag
3339	libc_errno = 0;
3340	written = LIBC_NAMESPACE::sprintf(buff, "%#-10m");
3341	ASSERT_STREQ_LEN(written, buff, "0 ");
3342
3343	libc_errno = ERANGE;
3344	written = LIBC_NAMESPACE::sprintf(buff, "%#-10m");
3345	ASSERT_STREQ_LEN(written, buff, "ERANGE ");
3346
3347	libc_errno = -9999;
3348	written = LIBC_NAMESPACE::sprintf(buff, "%#-10m");
3349	ASSERT_STREQ_LEN(written, buff, "-9999 ");
3350
3351	libc_errno = ERANGE;
3352	written = LIBC_NAMESPACE::sprintf(buff, "%#-3m");
3353	ASSERT_STREQ_LEN(written, buff, "ERANGE");
3354
3355	libc_errno = -9999;
3356	written = LIBC_NAMESPACE::sprintf(buff, "%#-3m");
3357	ASSERT_STREQ_LEN(written, buff, "-9999");
3358
3359	// '+' flag
3360	libc_errno = ERANGE;
3361	written = LIBC_NAMESPACE::sprintf(buff, "%#+m");
3362	ASSERT_STREQ_LEN(written, buff, "ERANGE");
3363
3364	libc_errno = -9999;
3365	written = LIBC_NAMESPACE::sprintf(buff, "%#+m");
3366	ASSERT_STREQ_LEN(written, buff, "-9999");
3367
3368	// Technically 9999 could be a valid error, since the standard just says errno
3369	// macros are "distinct positive values". In practice I don't expect this to
3370	// come up, but I've avoided it for the other %m tests for ease of
3371	// refactoring if necessary. Here it needs to be positive to test that the
3372	// flags that only affect positive signed integers are properly passed along.
3373	libc_errno = 9999;
3374	written = LIBC_NAMESPACE::sprintf(buff, "%#+m");
3375	ASSERT_STREQ_LEN(written, buff, "+9999");
3376
3377	// ' ' flag
3378	libc_errno = ERANGE;
3379	written = LIBC_NAMESPACE::sprintf(buff, "%# m");
3380	ASSERT_STREQ_LEN(written, buff, "ERANGE");
3381
3382	libc_errno = -9999;
3383	written = LIBC_NAMESPACE::sprintf(buff, "%# m");
3384	ASSERT_STREQ_LEN(written, buff, "-9999");
3385
3386	libc_errno = 9999;
3387	written = LIBC_NAMESPACE::sprintf(buff, "%# m");
3388	ASSERT_STREQ_LEN(written, buff, " 9999");
3389
3390	// '0' flag
3391
3392	libc_errno = ERANGE;
3393	written = LIBC_NAMESPACE::sprintf(buff, "%#010m");
3394	ASSERT_STREQ_LEN(written, buff, " ERANGE");
3395
3396	libc_errno = -9999;
3397	written = LIBC_NAMESPACE::sprintf(buff, "%#010m");
3398	ASSERT_STREQ_LEN(written, buff, "-000009999");
3399
3400	libc_errno = ERANGE;
3401	written = LIBC_NAMESPACE::sprintf(buff, "%#03m");
3402	ASSERT_STREQ_LEN(written, buff, "ERANGE");
3403
3404	libc_errno = -9999;
3405	written = LIBC_NAMESPACE::sprintf(buff, "%#03m");
3406	ASSERT_STREQ_LEN(written, buff, "-9999");
3407	}
3408	#endif // LIBC_COPT_PRINTF_DISABLE_STRERROR
3409
3410	#ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
3411	TEST(LlvmLibcSPrintfTest, WriteIntConv) {
3412	char buff[64];
3413	int written;
3414	int test_val = -1;
3415
3416	test_val = -1;
3417	written = LIBC_NAMESPACE::sprintf(buff, "12345%n67890", &test_val);
3418	EXPECT_EQ(test_val, 5);
3419	ASSERT_STREQ_LEN(written, buff, "1234567890");
3420
3421	test_val = -1;
3422	written = LIBC_NAMESPACE::sprintf(buff, "%n", &test_val);
3423	EXPECT_EQ(test_val, 0);
3424	ASSERT_STREQ_LEN(written, buff, "");
3425
3426	test_val = 0x100;
3427	written = LIBC_NAMESPACE::sprintf(buff, "ABC%hhnDEF", &test_val);
3428	EXPECT_EQ(test_val, 0x103);
3429	ASSERT_STREQ_LEN(written, buff, "ABCDEF");
3430
3431	test_val = -1;
3432	written = LIBC_NAMESPACE::sprintf(buff, "%s%n", "87654321", &test_val);
3433	EXPECT_EQ(test_val, 8);
3434	ASSERT_STREQ_LEN(written, buff, "87654321");
3435
3436	#ifndef LIBC_COPT_PRINTF_NO_NULLPTR_CHECKS
3437	written = LIBC_NAMESPACE::sprintf(buff, "abc123%n", nullptr);
3438	EXPECT_LT(written, 0);
3439	#endif // LIBC_COPT_PRINTF_NO_NULLPTR_CHECKS
3440	}
3441	#endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
3442
3443	#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
3444	TEST(LlvmLibcSPrintfTest, IndexModeParsing) {
3445	char buff[64];
3446	int written;
3447
3448	written = LIBC_NAMESPACE::sprintf(buff, "%1$s", "abcDEF123");
3449	ASSERT_STREQ_LEN(written, buff, "abcDEF123");
3450
3451	written = LIBC_NAMESPACE::sprintf(buff, "%1$s %%", "abcDEF123");
3452	ASSERT_STREQ_LEN(written, buff, "abcDEF123 %");
3453
3454	written =
3455	LIBC_NAMESPACE::sprintf(buff, "%3$s %1$s %2$s", "is", "hard", "ordering");
3456	ASSERT_STREQ_LEN(written, buff, "ordering is hard");
3457
3458	written = LIBC_NAMESPACE::sprintf(
3459	buff, "%10$s %9$s %8$c %7$s %6$s, %6$s %5$s %4$-*1$s %3$.*11$s %2$s. %%",
3460	6, "pain", "alphabetical", "such", "is", "this", "do", 'u', "would",
3461	"why", 1);
3462	ASSERT_STREQ_LEN(written, buff,
3463	"why would u do this, this is such a pain. %");
3464	}
3465	#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
3466