libc/test/src/stdio/sprintf_test.cpp

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