libc/test/src/stdlib/StrfromTest.h

   1 //===-- A template class for testing strfrom functions ----------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "src/__support/CPP/type_traits.h"
  10 #include "src/__support/FPUtil/FPBits.h"
  11 #include "test/UnitTest/Test.h"
  12
  13 #define ASSERT_STREQ_LEN(actual_written, actual_str, expected_str)             \
  14   EXPECT_EQ(actual_written, static_cast<int>(sizeof(expected_str) - 1));       \
  15   EXPECT_STREQ(actual_str, expected_str);
  16
  17 template <typename InputT>
  18 class StrfromTest : public LIBC_NAMESPACE::testing::Test {
  19
  20   static const bool is_single_prec =
  21       LIBC_NAMESPACE::cpp::is_same<InputT, float>::value;
  22   static const bool is_double_prec =
  23       LIBC_NAMESPACE::cpp::is_same<InputT, double>::value;
  24
  25   using FunctionT = int (*)(char *, size_t, const char *, InputT fp);
  26
  27 public:
  28   void floatDecimalFormat(FunctionT func) {
  29     if (is_single_prec)
  30       floatDecimalSinglePrec(func);
  31     else if (is_double_prec)
  32       floatDecimalDoublePrec(func);
  33     else
  34       floatDecimalLongDoublePrec(func);
  35   }
  36
  37   void floatHexExpFormat(FunctionT func) {
  38     if (is_single_prec)
  39       floatHexExpSinglePrec(func);
  40     else if (is_double_prec)
  41       floatHexExpDoublePrec(func);
  42     else
  43       floatHexExpLongDoublePrec(func);
  44   }
  45
  46   void floatDecimalExpFormat(FunctionT func) {
  47     if (is_single_prec)
  48       floatDecimalExpSinglePrec(func);
  49     else if (is_double_prec)
  50       floatDecimalExpDoublePrec(func);
  51     else
  52       floatDecimalExpLongDoublePrec(func);
  53   }
  54
  55   void floatDecimalAutoFormat(FunctionT func) {
  56     if (is_single_prec)
  57       floatDecimalAutoSinglePrec(func);
  58     else if (is_double_prec)
  59       floatDecimalAutoDoublePrec(func);
  60     else
  61       floatDecimalAutoLongDoublePrec(func);
  62   }
  63
  64   void improperFormatString(FunctionT func) {
  65     char buff[100];
  66     int written;
  67     const bool is_long_double = !is_single_prec && !is_double_prec;
  68
  69     written = func(buff, 37, "A simple string with no conversions.", 1.0);
  70     ASSERT_STREQ_LEN(written, buff, "A simple string with no conversions.");
  71
  72     written =
  73         func(buff, 37,
  74              "%A simple string with one conversion, should overwrite.", 1.0);
  75     if (is_long_double) {
  76 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
  77       ASSERT_STREQ_LEN(written, buff, "0X8P-3");
  78 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
  79       ASSERT_STREQ_LEN(written, buff, "0X1P+0");
  80 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
  81       ASSERT_STREQ_LEN(written, buff, "0X1P+0");
  82 #endif
  83     } else {
  84       // not long double
  85       ASSERT_STREQ_LEN(written, buff, "0X1P+0");
  86     }
  87     written = func(buff, 74,
  88                    "A simple string with one conversion in %A "
  89                    "between, writes string as it is",
  90                    1.0);
  91     ASSERT_STREQ_LEN(written, buff,
  92                      "A simple string with one conversion in %A between, "
  93                      "writes string as it is");
  94
  95     written = func(buff, 36, "A simple string with one conversion", 1.0);
  96     ASSERT_STREQ_LEN(written, buff, "A simple string with one conversion");
  97
  98     written = func(buff, 20, "%1f", 1234567890.0);
  99     ASSERT_STREQ_LEN(written, buff, "%1f");
 100   }
 101
 102   void insufficentBufsize(FunctionT func) {
 103     char buff[20];
 104     int written;
 105
 106     written = func(buff, 5, "%f", 1234567890.0);
 107     EXPECT_EQ(written, 17);
 108     ASSERT_STREQ(buff, "1234");
 109
 110     written = func(buff, 5, "%.5f", 1.05);
 111     EXPECT_EQ(written, 7);
 112     ASSERT_STREQ(buff, "1.05");
 113
 114     written = func(buff, 0, "%g", 1.0);
 115     EXPECT_EQ(written, 1);
 116     ASSERT_STREQ(buff, "1.05"); // Make sure that buff has not changed
 117   }
 118
 119   void infNanValues(FunctionT func) {
 120     if (is_double_prec)
 121       doublePrecInfNan(func);
 122     else if (!is_single_prec)
 123       longDoublePrecInfNan(func);
 124   }
 125
 126   void floatDecimalSinglePrec(FunctionT func) {
 127     char buff[70];
 128     int written;
 129
 130     written = func(buff, 16, "%f", 1.0);
 131     ASSERT_STREQ_LEN(written, buff, "1.000000");
 132
 133     written = func(buff, 20, "%f", 1234567890.0);
 134     ASSERT_STREQ_LEN(written, buff, "1234567936.000000");
 135
 136     written = func(buff, 67, "%.3f", 1.0);
 137     ASSERT_STREQ_LEN(written, buff, "1.000");
 138   }
 139
 140   void floatDecimalDoublePrec(FunctionT func) {
 141     char buff[500];
 142     int written;
 143
 144     written = func(buff, 99, "%f", 1.0);
 145     ASSERT_STREQ_LEN(written, buff, "1.000000");
 146
 147     written = func(buff, 99, "%F", -1.0);
 148     ASSERT_STREQ_LEN(written, buff, "-1.000000");
 149
 150     written = func(buff, 99, "%f", -1.234567);
 151     ASSERT_STREQ_LEN(written, buff, "-1.234567");
 152
 153     written = func(buff, 99, "%f", 0.0);
 154     ASSERT_STREQ_LEN(written, buff, "0.000000");
 155
 156     written = func(buff, 99, "%f", 1.5);
 157     ASSERT_STREQ_LEN(written, buff, "1.500000");
 158
 159 // Dyadic float is only accurate to ~50 digits, so skip this 300 digit test.
 160 // TODO: Create way to test just the first ~50 digits of a number.
 161 #ifndef LIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
 162     written = func(buff, 499, "%f", 1e300);
 163     ASSERT_STREQ_LEN(written, buff,
 164                      "100000000000000005250476025520442024870446858110815915491"
 165                      "585411551180245"
 166                      "798890819578637137508044786404370444383288387817694252323"
 167                      "536043057564479"
 168                      "218478670698284838720092657580373783023379478809005936895"
 169                      "323497079994508"
 170                      "111903896764088007465274278014249457925878882005684283811"
 171                      "566947219638686"
 172                      "5459400540160.000000");
 173 #endif // DLIBC_COPT_FLOAT_TO_STR_REDUCED_PRECISION
 174
 175     written = func(buff, 99, "%f", 0.1);
 176     ASSERT_STREQ_LEN(written, buff, "0.100000");
 177
 178     written = func(buff, 99, "%f", 1234567890123456789.0);
 179     ASSERT_STREQ_LEN(written, buff, "1234567890123456768.000000");
 180
 181     written = func(buff, 99, "%f", 9999999999999.99);
 182     ASSERT_STREQ_LEN(written, buff, "9999999999999.990234");
 183
 184     written = func(buff, 99, "%f", 0.1);
 185     ASSERT_STREQ_LEN(written, buff, "0.100000");
 186
 187     written = func(buff, 99, "%f", 1234567890123456789.0);
 188     ASSERT_STREQ_LEN(written, buff, "1234567890123456768.000000");
 189
 190     written = func(buff, 99, "%f", 9999999999999.99);
 191     ASSERT_STREQ_LEN(written, buff, "9999999999999.990234");
 192
 193     // Precision Tests
 194     written = func(buff, 100, "%.2f", 9999999999999.99);
 195     ASSERT_STREQ_LEN(written, buff, "9999999999999.99");
 196
 197     written = func(buff, 100, "%.1f", 9999999999999.99);
 198     ASSERT_STREQ_LEN(written, buff, "10000000000000.0");
 199
 200     written = func(buff, 100, "%.5f", 1.25);
 201     ASSERT_STREQ_LEN(written, buff, "1.25000");
 202
 203     written = func(buff, 100, "%.0f", 1.25);
 204     ASSERT_STREQ_LEN(written, buff, "1");
 205
 206     written = func(buff, 100, "%.20f", 1.234e-10);
 207     ASSERT_STREQ_LEN(written, buff, "0.00000000012340000000");
 208   }
 209
 210   void floatDecimalLongDoublePrec(FunctionT func) {
 211     char buff[45];
 212     int written;
 213
 214     written = func(buff, 40, "%f", 1.0L);
 215     ASSERT_STREQ_LEN(written, buff, "1.000000");
 216
 217     written = func(buff, 10, "%.f", -2.5L);
 218     ASSERT_STREQ_LEN(written, buff, "-2");
 219   }
 220
 221   void floatHexExpSinglePrec(FunctionT func) {
 222     char buff[25];
 223     int written;
 224
 225     written = func(buff, 0, "%a", 1234567890.0);
 226     EXPECT_EQ(written, 14);
 227
 228     written = func(buff, 20, "%a", 1234567890.0);
 229     EXPECT_EQ(written, 14);
 230     ASSERT_STREQ(buff, "0x1.26580cp+30");
 231
 232     written = func(buff, 20, "%A", 1234567890.0);
 233     EXPECT_EQ(written, 14);
 234     ASSERT_STREQ(buff, "0X1.26580CP+30");
 235   }
 236
 237   void floatHexExpDoublePrec(FunctionT func) {
 238     char buff[60];
 239     int written;
 240
 241     written = func(buff, 10, "%a", 1.0);
 242     ASSERT_STREQ_LEN(written, buff, "0x1p+0");
 243
 244     written = func(buff, 10, "%A", -1.0);
 245     ASSERT_STREQ_LEN(written, buff, "-0X1P+0");
 246
 247     written = func(buff, 30, "%a", -0x1.abcdef12345p0);
 248     ASSERT_STREQ_LEN(written, buff, "-0x1.abcdef12345p+0");
 249
 250     written = func(buff, 50, "%A", 0x1.abcdef12345p0);
 251     ASSERT_STREQ_LEN(written, buff, "0X1.ABCDEF12345P+0");
 252
 253     written = func(buff, 10, "%a", 0.0);
 254     ASSERT_STREQ_LEN(written, buff, "0x0p+0");
 255
 256     written = func(buff, 40, "%a", 1.0e100);
 257     ASSERT_STREQ_LEN(written, buff, "0x1.249ad2594c37dp+332");
 258
 259     written = func(buff, 30, "%a", 0.1);
 260     ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4");
 261   }
 262
 263   void floatHexExpLongDoublePrec(FunctionT func) {
 264     char buff[55];
 265     int written;
 266
 267     written = func(buff, 50, "%a", 0.1L);
 268 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
 269     ASSERT_STREQ_LEN(written, buff, "0xc.ccccccccccccccdp-7");
 270 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
 271     ASSERT_STREQ_LEN(written, buff, "0x1.999999999999ap-4");
 272 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
 273     ASSERT_STREQ_LEN(written, buff, "0x1.999999999999999999999999999ap-4");
 274 #endif
 275
 276     written = func(buff, 20, "%.1a", 0.1L);
 277 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
 278     ASSERT_STREQ_LEN(written, buff, "0xc.dp-7");
 279 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
 280     ASSERT_STREQ_LEN(written, buff, "0x1.ap-4");
 281 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
 282     ASSERT_STREQ_LEN(written, buff, "0x1.ap-4");
 283 #endif
 284
 285     written = func(buff, 50, "%a", 1.0e1000L);
 286 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
 287     ASSERT_STREQ_LEN(written, buff, "0xf.38db1f9dd3dac05p+3318");
 288 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
 289     ASSERT_STREQ_LEN(written, buff, "inf");
 290 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
 291     ASSERT_STREQ_LEN(written, buff, "0x1.e71b63f3ba7b580af1a52d2a7379p+3321");
 292 #endif
 293
 294     written = func(buff, 50, "%a", 1.0e-1000L);
 295 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
 296     ASSERT_STREQ_LEN(written, buff, "0x8.68a9188a89e1467p-3325");
 297 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
 298     ASSERT_STREQ_LEN(written, buff, "0x0p+0");
 299 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
 300     ASSERT_STREQ_LEN(written, buff, "0x1.0d152311513c28ce202627c06ec2p-3322");
 301 #endif
 302
 303     written = func(buff, 50, "%.1a", 0xf.fffffffffffffffp16380L);
 304 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
 305     ASSERT_STREQ_LEN(written, buff, "0x1.0p+16384");
 306 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64)
 307     ASSERT_STREQ_LEN(written, buff, "inf");
 308 #elif defined(LIBC_TYPES_LONG_DOUBLE_IS_FLOAT128)
 309     ASSERT_STREQ_LEN(written, buff, "0x2.0p+16383");
 310 #endif
 311   }
 312
 313   void floatDecimalExpSinglePrec(FunctionT func) {
 314     char buff[25];
 315     int written;
 316
 317     written = func(buff, 20, "%.9e", 1234567890.0);
 318     ASSERT_STREQ_LEN(written, buff, "1.234567936e+09");
 319
 320     written = func(buff, 20, "%.9E", 1234567890.0);
 321     ASSERT_STREQ_LEN(written, buff, "1.234567936E+09");
 322   }
 323
 324   void floatDecimalExpDoublePrec(FunctionT func) {
 325     char buff[101];
 326     int written;
 327
 328     written = func(buff, 100, "%e", 1.0);
 329     ASSERT_STREQ_LEN(written, buff, "1.000000e+00");
 330
 331     written = func(buff, 100, "%E", -1.0);
 332     ASSERT_STREQ_LEN(written, buff, "-1.000000E+00");
 333
 334     written = func(buff, 100, "%e", -1.234567);
 335     ASSERT_STREQ_LEN(written, buff, "-1.234567e+00");
 336
 337     written = func(buff, 100, "%e", 0.0);
 338     ASSERT_STREQ_LEN(written, buff, "0.000000e+00");
 339
 340     written = func(buff, 100, "%e", 1.5);
 341     ASSERT_STREQ_LEN(written, buff, "1.500000e+00");
 342
 343     written = func(buff, 100, "%e", 1e300);
 344     ASSERT_STREQ_LEN(written, buff, "1.000000e+300");
 345
 346     written = func(buff, 100, "%e", 1234567890123456789.0);
 347     ASSERT_STREQ_LEN(written, buff, "1.234568e+18");
 348
 349     // Precision Tests
 350     written = func(buff, 100, "%.1e", 1.0);
 351     ASSERT_STREQ_LEN(written, buff, "1.0e+00");
 352
 353     written = func(buff, 100, "%.1e", 1.99);
 354     ASSERT_STREQ_LEN(written, buff, "2.0e+00");
 355
 356     written = func(buff, 100, "%.1e", 9.99);
 357     ASSERT_STREQ_LEN(written, buff, "1.0e+01");
 358   }
 359
 360   void floatDecimalExpLongDoublePrec(FunctionT func) {
 361     // Mark as maybe_unused to silence unused variable
 362     // warning when long double is not 80-bit
 363     [[maybe_unused]] char buff[100];
 364     [[maybe_unused]] int written;
 365
 366 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
 367     written = func(buff, 90, "%.9e", 1000000000500000000.1L);
 368     ASSERT_STREQ_LEN(written, buff, "1.000000001e+18");
 369
 370     written = func(buff, 90, "%.9e", 1000000000500000000.0L);
 371     ASSERT_STREQ_LEN(written, buff, "1.000000000e+18");
 372
 373     written = func(buff, 90, "%e", 0xf.fffffffffffffffp+16380L);
 374     ASSERT_STREQ_LEN(written, buff, "1.189731e+4932");
 375 #endif // LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80
 376   }
 377
 378   void floatDecimalAutoSinglePrec(FunctionT func) {
 379     char buff[25];
 380     int written;
 381
 382     written = func(buff, 20, "%.9g", 1234567890.0);
 383     ASSERT_STREQ_LEN(written, buff, "1.23456794e+09");
 384
 385     written = func(buff, 20, "%.9G", 1234567890.0);
 386     ASSERT_STREQ_LEN(written, buff, "1.23456794E+09");
 387   }
 388
 389   void floatDecimalAutoDoublePrec(FunctionT func) {
 390     char buff[120];
 391     int written;
 392
 393     written = func(buff, 100, "%g", 1234567890123456789.0);
 394     ASSERT_STREQ_LEN(written, buff, "1.23457e+18");
 395
 396     written = func(buff, 100, "%g", 9999990000000.00);
 397     ASSERT_STREQ_LEN(written, buff, "9.99999e+12");
 398
 399     written = func(buff, 100, "%g", 9999999000000.00);
 400     ASSERT_STREQ_LEN(written, buff, "1e+13");
 401
 402     written = func(buff, 100, "%g", 0xa.aaaaaaaaaaaaaabp-7);
 403     ASSERT_STREQ_LEN(written, buff, "0.0833333");
 404
 405     written = func(buff, 100, "%g", 0.00001);
 406     ASSERT_STREQ_LEN(written, buff, "1e-05");
 407
 408     // Precision Tests
 409     written = func(buff, 100, "%.0g", 0.0);
 410     ASSERT_STREQ_LEN(written, buff, "0");
 411
 412     written = func(buff, 100, "%.2g", 0.1);
 413     ASSERT_STREQ_LEN(written, buff, "0.1");
 414
 415     written = func(buff, 100, "%.2g", 1.09);
 416     ASSERT_STREQ_LEN(written, buff, "1.1");
 417
 418     written = func(buff, 100, "%.15g", 22.25);
 419     ASSERT_STREQ_LEN(written, buff, "22.25");
 420
 421     written = func(buff, 100, "%.20g", 1.234e-10);
 422     ASSERT_STREQ_LEN(written, buff, "1.2340000000000000814e-10");
 423   }
 424
 425   void floatDecimalAutoLongDoublePrec(FunctionT func) {
 426     // Mark as maybe_unused to silence unused variable
 427     // warning when long double is not 80-bit
 428     [[maybe_unused]] char buff[100];
 429     [[maybe_unused]] int written;
 430
 431 #if defined(LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80)
 432     written = func(buff, 99, "%g", 0xf.fffffffffffffffp+16380L);
 433     ASSERT_STREQ_LEN(written, buff, "1.18973e+4932");
 434
 435     written = func(buff, 99, "%g", 0xa.aaaaaaaaaaaaaabp-7L);
 436     ASSERT_STREQ_LEN(written, buff, "0.0833333");
 437
 438     written = func(buff, 99, "%g", 9.99999999999e-100L);
 439     ASSERT_STREQ_LEN(written, buff, "1e-99");
 440 #endif // LIBC_TYPES_LONG_DOUBLE_IS_X86_FLOAT80
 441   }
 442
 443   void doublePrecInfNan(FunctionT func) {
 444     char buff[15];
 445     int written;
 446
 447     double inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
 448     double nan = LIBC_NAMESPACE::fputil::FPBits<double>::quiet_nan().get_val();
 449
 450     written = func(buff, 10, "%f", inf);
 451     ASSERT_STREQ_LEN(written, buff, "inf");
 452
 453     written = func(buff, 10, "%A", -inf);
 454     ASSERT_STREQ_LEN(written, buff, "-INF");
 455
 456     written = func(buff, 10, "%f", nan);
 457     ASSERT_STREQ_LEN(written, buff, "nan");
 458
 459     written = func(buff, 10, "%A", -nan);
 460     ASSERT_STREQ_LEN(written, buff, "-NAN");
 461   }
 462
 463   void longDoublePrecInfNan(FunctionT func) {
 464     char buff[15];
 465     int written;
 466
 467     long double ld_inf =
 468         LIBC_NAMESPACE::fputil::FPBits<long double>::inf().get_val();
 469     long double ld_nan =
 470         LIBC_NAMESPACE::fputil::FPBits<long double>::quiet_nan().get_val();
 471
 472     written = func(buff, 10, "%f", ld_inf);
 473     ASSERT_STREQ_LEN(written, buff, "inf");
 474
 475     written = func(buff, 10, "%A", -ld_inf);
 476     ASSERT_STREQ_LEN(written, buff, "-INF");
 477
 478     written = func(buff, 10, "%f", ld_nan);
 479     ASSERT_STREQ_LEN(written, buff, "nan");
 480
 481     written = func(buff, 10, "%A", -ld_nan);
 482     ASSERT_STREQ_LEN(written, buff, "-NAN");
 483   }
 484 };
 485
 486 #define STRFROM_TEST(InputType, name, func)                                    \
 487   using LlvmLibc##name##Test = StrfromTest<InputType>;                         \
 488   TEST_F(LlvmLibc##name##Test, FloatDecimalFormat) {                           \
 489     floatDecimalFormat(func);                                                  \
 490   }                                                                            \
 491   TEST_F(LlvmLibc##name##Test, FloatHexExpFormat) { floatHexExpFormat(func); } \
 492   TEST_F(LlvmLibc##name##Test, FloatDecimalAutoFormat) {                       \
 493     floatDecimalAutoFormat(func);                                              \
 494   }                                                                            \
 495   TEST_F(LlvmLibc##name##Test, FloatDecimalExpFormat) {                        \
 496     floatDecimalExpFormat(func);                                               \
 497   }                                                                            \
 498   TEST_F(LlvmLibc##name##Test, ImproperFormatString) {                         \
 499     improperFormatString(func);                                                \
 500   }                                                                            \
 501   TEST_F(LlvmLibc##name##Test, InsufficientBufferSize) {                       \
 502     insufficentBufsize(func);                                                  \
 503   }                                                                            \
 504   TEST_F(LlvmLibc##name##Test, InfAndNanValues) { infNanValues(func); }