libc/test/src/stdio/sscanf_test.cpp

   1 //===-- Unittests for sscanf ----------------------------------------------===//
   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/sscanf.h"
  10
  11 #include "hdr/stdio_macros.h" // For EOF
  12 #include "src/__support/CPP/limits.h"
  13 #include "src/__support/FPUtil/FPBits.h"
  14 #include "test/UnitTest/FPMatcher.h"
  15 #include "test/UnitTest/Test.h"
  16
  17 TEST(LlvmLibcSScanfTest, SimpleStringConv) {
  18   int ret_val;
  19   char buffer[10];
  20   char buffer2[10];
  21   ret_val = LIBC_NAMESPACE::sscanf("abc123", "abc %s", buffer);
  22   ASSERT_EQ(ret_val, 1);
  23   ASSERT_STREQ(buffer, "123");
  24
  25   ret_val = LIBC_NAMESPACE::sscanf("abc123", "%3s %3s", buffer, buffer2);
  26   ASSERT_EQ(ret_val, 2);
  27   ASSERT_STREQ(buffer, "abc");
  28   ASSERT_STREQ(buffer2, "123");
  29
  30   ret_val = LIBC_NAMESPACE::sscanf("abc 123", "%3s%3s", buffer, buffer2);
  31   ASSERT_EQ(ret_val, 2);
  32   ASSERT_STREQ(buffer, "abc");
  33   ASSERT_STREQ(buffer2, "123");
  34 }
  35
  36 TEST(LlvmLibcSScanfTest, IntConvSimple) {
  37   int ret_val;
  38   int result = 0;
  39   ret_val = LIBC_NAMESPACE::sscanf("123", "%d", &result);
  40   EXPECT_EQ(ret_val, 1);
  41   EXPECT_EQ(result, 123);
  42
  43   ret_val = LIBC_NAMESPACE::sscanf("456", "%i", &result);
  44   EXPECT_EQ(ret_val, 1);
  45   EXPECT_EQ(result, 456);
  46
  47   ret_val = LIBC_NAMESPACE::sscanf("789", "%x", &result);
  48   EXPECT_EQ(ret_val, 1);
  49   EXPECT_EQ(result, 0x789);
  50
  51   ret_val = LIBC_NAMESPACE::sscanf("012", "%o", &result);
  52   EXPECT_EQ(ret_val, 1);
  53   EXPECT_EQ(result, 012);
  54
  55   ret_val = LIBC_NAMESPACE::sscanf("345", "%u", &result);
  56   EXPECT_EQ(ret_val, 1);
  57   EXPECT_EQ(result, 345);
  58
  59   // 288 characters
  60   ret_val = LIBC_NAMESPACE::sscanf("10000000000000000000000000000000"
  61                                    "00000000000000000000000000000000"
  62                                    "00000000000000000000000000000000"
  63                                    "00000000000000000000000000000000"
  64                                    "00000000000000000000000000000000"
  65                                    "00000000000000000000000000000000"
  66                                    "00000000000000000000000000000000"
  67                                    "00000000000000000000000000000000"
  68                                    "00000000000000000000000000000000",
  69                                    "%d", &result);
  70   EXPECT_EQ(ret_val, 1);
  71   EXPECT_EQ(result, int(LIBC_NAMESPACE::cpp::numeric_limits<intmax_t>::max()));
  72
  73   ret_val = LIBC_NAMESPACE::sscanf("Not an integer", "%d", &result);
  74   EXPECT_EQ(ret_val, 0);
  75 }
  76
  77 TEST(LlvmLibcSScanfTest, IntConvLengthModifier) {
  78   int ret_val;
  79   uintmax_t max_result = 0;
  80   int int_result = 0;
  81   char char_result = 0;
  82
  83   ret_val = LIBC_NAMESPACE::sscanf("123", "%ju", &max_result);
  84   EXPECT_EQ(ret_val, 1);
  85   EXPECT_EQ(max_result, uintmax_t(123));
  86
  87   // Check overflow handling
  88   ret_val = LIBC_NAMESPACE::sscanf("999999999999999999999999999999999999",
  89                                    "%ju", &max_result);
  90   EXPECT_EQ(ret_val, 1);
  91   EXPECT_EQ(max_result, LIBC_NAMESPACE::cpp::numeric_limits<uintmax_t>::max());
  92
  93   // Because this is unsigned, any out of range value should return the maximum,
  94   // even with a negative sign.
  95   ret_val = LIBC_NAMESPACE::sscanf("-999999999999999999999999999999999999",
  96                                    "%ju", &max_result);
  97   EXPECT_EQ(ret_val, 1);
  98   EXPECT_EQ(max_result, LIBC_NAMESPACE::cpp::numeric_limits<uintmax_t>::max());
  99
 100   ret_val = LIBC_NAMESPACE::sscanf("-18446744073709551616", "%ju", &max_result);
 101   EXPECT_EQ(ret_val, 1);
 102   EXPECT_EQ(max_result, LIBC_NAMESPACE::cpp::numeric_limits<uintmax_t>::max());
 103
 104   // But any number below the maximum should have the - sign applied.
 105   ret_val = LIBC_NAMESPACE::sscanf("-1", "%ju", &max_result);
 106   EXPECT_EQ(ret_val, 1);
 107   EXPECT_EQ(max_result, uintmax_t(-1));
 108
 109   ret_val = LIBC_NAMESPACE::sscanf("-1", "%u", &int_result);
 110   EXPECT_EQ(ret_val, 1);
 111   EXPECT_EQ(int_result, -1);
 112
 113   max_result = 0xff00ff00ff00ff00;
 114   char_result = 0x6f;
 115
 116   // Overflows for sizes larger than the maximum are handled by casting.
 117   ret_val = LIBC_NAMESPACE::sscanf("8589967360", "%d", &int_result);
 118   EXPECT_EQ(ret_val, 1);
 119   EXPECT_EQ(int_result, int(8589967360)); // 2^33 + 2^15
 120
 121   // Check that the adjacent values weren't touched by the overflow.
 122   ASSERT_EQ(max_result, uintmax_t(0xff00ff00ff00ff00));
 123   ASSERT_EQ(char_result, char(0x6f));
 124
 125   ret_val = LIBC_NAMESPACE::sscanf("-8589967360", "%d", &int_result);
 126   EXPECT_EQ(ret_val, 1);
 127   EXPECT_EQ(int_result, int(-8589967360));
 128   ASSERT_EQ(max_result, uintmax_t(0xff00ff00ff00ff00));
 129   ASSERT_EQ(char_result, char(0x6f));
 130
 131   ret_val = LIBC_NAMESPACE::sscanf("25", "%hhd", &char_result);
 132   EXPECT_EQ(ret_val, 1);
 133   EXPECT_EQ(char_result, char(25));
 134 }
 135
 136 TEST(LlvmLibcSScanfTest, IntConvBaseSelection) {
 137   int ret_val;
 138   int result = 0;
 139   ret_val = LIBC_NAMESPACE::sscanf("0xabc123", "%i", &result);
 140   EXPECT_EQ(ret_val, 1);
 141   EXPECT_EQ(result, 0xabc123);
 142
 143   ret_val = LIBC_NAMESPACE::sscanf("0456", "%i", &result);
 144   EXPECT_EQ(ret_val, 1);
 145   EXPECT_EQ(result, 0456);
 146
 147   ret_val = LIBC_NAMESPACE::sscanf("0999", "%i", &result);
 148   EXPECT_EQ(ret_val, 1);
 149   EXPECT_EQ(result, 0);
 150
 151   ret_val = LIBC_NAMESPACE::sscanf("123abc456", "%i", &result);
 152   EXPECT_EQ(ret_val, 1);
 153   EXPECT_EQ(result, 123);
 154 }
 155
 156 TEST(LlvmLibcSScanfTest, IntConvMaxLengthTests) {
 157   int ret_val;
 158   int result = 0;
 159
 160   ret_val = LIBC_NAMESPACE::sscanf("12", "%1d", &result);
 161   EXPECT_EQ(ret_val, 1);
 162   EXPECT_EQ(result, 1);
 163
 164   ret_val = LIBC_NAMESPACE::sscanf("-1", "%1d", &result);
 165   EXPECT_EQ(ret_val, 0);
 166   EXPECT_EQ(result, 0);
 167
 168   ret_val = LIBC_NAMESPACE::sscanf("+1", "%1d", &result);
 169   EXPECT_EQ(ret_val, 0);
 170   EXPECT_EQ(result, 0);
 171
 172   ret_val = LIBC_NAMESPACE::sscanf("01", "%1d", &result);
 173   EXPECT_EQ(ret_val, 1);
 174   EXPECT_EQ(result, 0);
 175
 176   ret_val = LIBC_NAMESPACE::sscanf("01", "%1i", &result);
 177   EXPECT_EQ(ret_val, 1);
 178   EXPECT_EQ(result, 0);
 179
 180   result = -999;
 181
 182   // 0x is a valid prefix, but not a valid number. This should be a matching
 183   // failure and should not modify the values.
 184   ret_val = LIBC_NAMESPACE::sscanf("0x1", "%2i", &result);
 185   EXPECT_EQ(ret_val, 0);
 186   EXPECT_EQ(result, -999);
 187
 188   ret_val = LIBC_NAMESPACE::sscanf("-0x1", "%3i", &result);
 189   EXPECT_EQ(ret_val, 0);
 190   EXPECT_EQ(result, -999);
 191
 192   ret_val = LIBC_NAMESPACE::sscanf("0x1", "%3i", &result);
 193   EXPECT_EQ(ret_val, 1);
 194   EXPECT_EQ(result, 1);
 195
 196   ret_val = LIBC_NAMESPACE::sscanf("-0x1", "%4i", &result);
 197   EXPECT_EQ(ret_val, 1);
 198   EXPECT_EQ(result, -1);
 199
 200   ret_val = LIBC_NAMESPACE::sscanf("-0x123", "%4i", &result);
 201   EXPECT_EQ(ret_val, 1);
 202   EXPECT_EQ(result, -1);
 203
 204   ret_val = LIBC_NAMESPACE::sscanf("123456789", "%5i", &result);
 205   EXPECT_EQ(ret_val, 1);
 206   EXPECT_EQ(result, 12345);
 207
 208   ret_val = LIBC_NAMESPACE::sscanf("123456789", "%10i", &result);
 209   EXPECT_EQ(ret_val, 1);
 210   EXPECT_EQ(result, 123456789);
 211 }
 212
 213 TEST(LlvmLibcSScanfTest, IntConvNoWriteTests) {
 214   int ret_val;
 215   // Result shouldn't be used by these tests, but it's safer to have it and
 216   // check it.
 217   int result = 0;
 218   ret_val = LIBC_NAMESPACE::sscanf("-1", "%*1d", &result);
 219   EXPECT_EQ(ret_val, 0);
 220   EXPECT_EQ(result, 0);
 221
 222   ret_val = LIBC_NAMESPACE::sscanf("01", "%*1i", &result);
 223   EXPECT_EQ(ret_val, 1);
 224   EXPECT_EQ(result, 0);
 225
 226   ret_val = LIBC_NAMESPACE::sscanf("0x1", "%*2i", &result);
 227   EXPECT_EQ(ret_val, 0);
 228   EXPECT_EQ(result, 0);
 229
 230   ret_val = LIBC_NAMESPACE::sscanf("a", "%*i", &result);
 231   EXPECT_EQ(ret_val, 0);
 232   EXPECT_EQ(result, 0);
 233
 234   ret_val = LIBC_NAMESPACE::sscanf("123", "%*i", &result);
 235   EXPECT_EQ(ret_val, 1);
 236   EXPECT_EQ(result, 0);
 237 }
 238
 239 #ifndef LIBC_COPT_SCANF_DISABLE_FLOAT
 240 TEST(LlvmLibcSScanfTest, FloatConvSimple) {
 241   int ret_val;
 242   float result = 0;
 243
 244   float inf = LIBC_NAMESPACE::fputil::FPBits<float>::inf().get_val();
 245   float nan = LIBC_NAMESPACE::fputil::FPBits<float>::quiet_nan().get_val();
 246
 247   ret_val = LIBC_NAMESPACE::sscanf("123", "%f", &result);
 248   EXPECT_EQ(ret_val, 1);
 249   EXPECT_FP_EQ(result, 123.0);
 250
 251   ret_val = LIBC_NAMESPACE::sscanf("456.1", "%a", &result);
 252   EXPECT_EQ(ret_val, 1);
 253   EXPECT_FP_EQ(result, 456.1);
 254
 255   ret_val = LIBC_NAMESPACE::sscanf("0x789.ap0", "%e", &result);
 256   EXPECT_EQ(ret_val, 1);
 257   EXPECT_FP_EQ(result, 0x789.ap0);
 258
 259   ret_val = LIBC_NAMESPACE::sscanf("0x.8", "%e", &result);
 260   EXPECT_EQ(ret_val, 1);
 261   EXPECT_FP_EQ(result, 0x0.8p0);
 262
 263   ret_val = LIBC_NAMESPACE::sscanf("0x8.", "%e", &result);
 264   EXPECT_EQ(ret_val, 1);
 265   EXPECT_FP_EQ(result, 0x8.0p0);
 266
 267   ret_val = LIBC_NAMESPACE::sscanf("+12.0e1", "%g", &result);
 268   EXPECT_EQ(ret_val, 1);
 269   EXPECT_FP_EQ(result, 12.0e1);
 270
 271   ret_val = LIBC_NAMESPACE::sscanf("inf", "%F", &result);
 272   EXPECT_EQ(ret_val, 1);
 273   EXPECT_FP_EQ(result, inf);
 274
 275   ret_val = LIBC_NAMESPACE::sscanf("NaN", "%A", &result);
 276   EXPECT_EQ(ret_val, 1);
 277   EXPECT_FP_EQ(result, nan);
 278
 279   ret_val = LIBC_NAMESPACE::sscanf("-InFiNiTy", "%E", &result);
 280   EXPECT_EQ(ret_val, 1);
 281   EXPECT_FP_EQ(result, -inf);
 282
 283   ret_val = LIBC_NAMESPACE::sscanf("1e10", "%G", &result);
 284   EXPECT_EQ(ret_val, 1);
 285   EXPECT_FP_EQ(result, 1e10);
 286
 287   ret_val = LIBC_NAMESPACE::sscanf(".1", "%G", &result);
 288   EXPECT_EQ(ret_val, 1);
 289   EXPECT_FP_EQ(result, 0.1);
 290
 291   ret_val = LIBC_NAMESPACE::sscanf("1.", "%G", &result);
 292   EXPECT_EQ(ret_val, 1);
 293   EXPECT_FP_EQ(result, 1.0);
 294
 295   ret_val = LIBC_NAMESPACE::sscanf("0", "%f", &result);
 296   EXPECT_EQ(ret_val, 1);
 297   EXPECT_FP_EQ(result, 0.0);
 298
 299   ret_val = LIBC_NAMESPACE::sscanf("Not a float", "%f", &result);
 300   EXPECT_EQ(ret_val, 0);
 301 }
 302
 303 TEST(LlvmLibcSScanfTest, FloatConvLengthModifier) {
 304   int ret_val;
 305   double d_result = 0;
 306   long double ld_result = 0;
 307
 308   double d_inf = LIBC_NAMESPACE::fputil::FPBits<double>::inf().get_val();
 309   long double ld_nan =
 310       LIBC_NAMESPACE::fputil::FPBits<long double>::quiet_nan().get_val();
 311
 312   ret_val = LIBC_NAMESPACE::sscanf("123", "%lf", &d_result);
 313   EXPECT_EQ(ret_val, 1);
 314   EXPECT_FP_EQ(d_result, 123.0);
 315
 316   ret_val = LIBC_NAMESPACE::sscanf("456.1", "%La", &ld_result);
 317   EXPECT_EQ(ret_val, 1);
 318   EXPECT_FP_EQ(ld_result, 456.1L);
 319
 320   ret_val = LIBC_NAMESPACE::sscanf("inf", "%le", &d_result);
 321   EXPECT_EQ(ret_val, 1);
 322   EXPECT_FP_EQ(d_result, d_inf);
 323
 324   ret_val = LIBC_NAMESPACE::sscanf("nan", "%Lg", &ld_result);
 325   EXPECT_EQ(ret_val, 1);
 326   EXPECT_FP_EQ(ld_result, ld_nan);
 327
 328   ret_val = LIBC_NAMESPACE::sscanf("1e-300", "%lF", &d_result);
 329   EXPECT_EQ(ret_val, 1);
 330   EXPECT_FP_EQ(d_result, 1e-300);
 331
 332   ret_val = LIBC_NAMESPACE::sscanf("1.0e600", "%LA", &ld_result);
 333   EXPECT_EQ(ret_val, 1);
 334 // 1e600 may be larger than the maximum long double (if long double is double).
 335 // In that case both of these should be evaluated as inf.
 336 #ifdef LIBC_TYPES_LONG_DOUBLE_IS_FLOAT64
 337   EXPECT_FP_EQ(ld_result, d_inf);
 338 #else
 339   EXPECT_FP_EQ(ld_result, 1.0e600L);
 340 #endif
 341 }
 342
 343 TEST(LlvmLibcSScanfTest, FloatConvLongNumber) {
 344   int ret_val;
 345   float result = 0;
 346   double d_result = 0;
 347
 348   // 32 characters
 349   ret_val =
 350       LIBC_NAMESPACE::sscanf("123456789012345678901234567890.0", "%f", &result);
 351   EXPECT_EQ(ret_val, 1);
 352   EXPECT_FP_EQ(result, 123456789012345678901234567890.0f);
 353
 354   // 64 characters
 355   ret_val = LIBC_NAMESPACE::sscanf(
 356       "123456789012345678901234567890123456789012345678901234567890.000", "%la",
 357       &d_result);
 358   EXPECT_EQ(ret_val, 1);
 359   EXPECT_FP_EQ(
 360       d_result,
 361       123456789012345678901234567890123456789012345678901234567890.000);
 362
 363   // 128 characters
 364   ret_val = LIBC_NAMESPACE::sscanf(
 365       "123456789012345678901234567890123456789012345678901234567890"
 366       "123456789012345678901234567890123456789012345678901234567890.0000000",
 367       "%le", &d_result);
 368   EXPECT_EQ(ret_val, 1);
 369   EXPECT_FP_EQ(
 370       d_result,
 371       123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.0000000);
 372
 373   // 256 characters
 374   ret_val = LIBC_NAMESPACE::sscanf("10000000000000000000000000000000"
 375                                    "00000000000000000000000000000000"
 376                                    "00000000000000000000000000000000"
 377                                    "00000000000000000000000000000000"
 378                                    "00000000000000000000000000000000"
 379                                    "00000000000000000000000000000000"
 380                                    "00000000000000000000000000000000"
 381                                    "00000000000000000000000000000000",
 382                                    "%lf", &d_result);
 383   EXPECT_EQ(ret_val, 1);
 384   EXPECT_FP_EQ(d_result, 1e255);
 385
 386   // 288 characters
 387   ret_val = LIBC_NAMESPACE::sscanf("10000000000000000000000000000000"
 388                                    "00000000000000000000000000000000"
 389                                    "00000000000000000000000000000000"
 390                                    "00000000000000000000000000000000"
 391                                    "00000000000000000000000000000000"
 392                                    "00000000000000000000000000000000"
 393                                    "00000000000000000000000000000000"
 394                                    "00000000000000000000000000000000"
 395                                    "00000000000000000000000000000000",
 396                                    "%lf", &d_result);
 397   EXPECT_EQ(ret_val, 1);
 398   EXPECT_FP_EQ(d_result, 1e287);
 399 }
 400
 401 TEST(LlvmLibcSScanfTest, FloatConvComplexParsing) {
 402   int ret_val;
 403   float result = 0;
 404
 405   float inf = LIBC_NAMESPACE::fputil::FPBits<float>::inf().get_val();
 406   float nan = LIBC_NAMESPACE::fputil::FPBits<float>::quiet_nan().get_val();
 407
 408   ret_val = LIBC_NAMESPACE::sscanf("0x1.0e3", "%f", &result);
 409   EXPECT_EQ(ret_val, 1);
 410   EXPECT_FP_EQ(result, 0x1.0e3p0);
 411
 412   ret_val = LIBC_NAMESPACE::sscanf("", "%a", &result);
 413   EXPECT_EQ(ret_val, 0);
 414
 415   ret_val = LIBC_NAMESPACE::sscanf("+", "%a", &result);
 416   EXPECT_EQ(ret_val, 0);
 417
 418   ret_val = LIBC_NAMESPACE::sscanf("-", "%a", &result);
 419   EXPECT_EQ(ret_val, 0);
 420
 421   ret_val = LIBC_NAMESPACE::sscanf("+.", "%a", &result);
 422   EXPECT_EQ(ret_val, 0);
 423
 424   ret_val = LIBC_NAMESPACE::sscanf("-.e+10", "%a", &result);
 425   EXPECT_EQ(ret_val, 0);
 426
 427   // This is a specific example from the standard. Its behavior diverges from
 428   // other implementations that accept "100e" as being the same as "100e0"
 429   ret_val = LIBC_NAMESPACE::sscanf("100er", "%a", &result);
 430   EXPECT_EQ(ret_val, 0);
 431
 432   ret_val = LIBC_NAMESPACE::sscanf("nah", "%a", &result);
 433   EXPECT_EQ(ret_val, 0);
 434
 435   ret_val = LIBC_NAMESPACE::sscanf("indirection", "%a", &result);
 436   EXPECT_EQ(ret_val, 0);
 437
 438   ret_val = LIBC_NAMESPACE::sscanf("infnan", "%a", &result);
 439   EXPECT_EQ(ret_val, 1);
 440   EXPECT_FP_EQ(result, inf);
 441
 442   ret_val = LIBC_NAMESPACE::sscanf("naninf", "%a", &result);
 443   EXPECT_EQ(ret_val, 1);
 444   EXPECT_FP_EQ(result, nan);
 445
 446   ret_val = LIBC_NAMESPACE::sscanf("infinityinfinity", "%a", &result);
 447   EXPECT_EQ(ret_val, 1);
 448   EXPECT_FP_EQ(result, inf);
 449
 450   // For %f to accept a string as representing it has to be either "inf" or
 451   // "infinity" when it stops. It only stops when it encounters a character that
 452   // isn't the next one in the string, so it accepts "infi" as the the longest
 453   // prefix of a possibly valid floating-point number, but determines that it is
 454   // not valid and returns a matching failure. This is because it can only unget
 455   // one character so when it finds that the character after the second 'i' is
 456   // not the next character in "infinity" it can't rewind to the point where it
 457   // had just "inf".
 458   ret_val = LIBC_NAMESPACE::sscanf("infi", "%a", &result);
 459   EXPECT_EQ(ret_val, 0);
 460
 461   ret_val = LIBC_NAMESPACE::sscanf("infinite", "%a", &result);
 462   EXPECT_EQ(ret_val, 0);
 463
 464   ret_val = LIBC_NAMESPACE::sscanf("-.1e1", "%f", &result);
 465   EXPECT_EQ(ret_val, 1);
 466   EXPECT_FP_EQ(result, -.1e1);
 467
 468   ret_val = LIBC_NAMESPACE::sscanf("1.2.e1", "%f", &result);
 469   EXPECT_EQ(ret_val, 1);
 470   EXPECT_FP_EQ(result, 1.2);
 471 }
 472
 473 TEST(LlvmLibcSScanfTest, FloatConvMaxWidth) {
 474   int ret_val;
 475   float result = 0;
 476
 477   float inf = LIBC_NAMESPACE::fputil::FPBits<float>::inf().get_val();
 478
 479   ret_val = LIBC_NAMESPACE::sscanf("123", "%3f", &result);
 480   EXPECT_EQ(ret_val, 1);
 481   EXPECT_FP_EQ(result, 123.0);
 482
 483   ret_val = LIBC_NAMESPACE::sscanf("123", "%5f", &result);
 484   EXPECT_EQ(ret_val, 1);
 485   EXPECT_FP_EQ(result, 123.0);
 486
 487   ret_val = LIBC_NAMESPACE::sscanf("456", "%1f", &result);
 488   EXPECT_EQ(ret_val, 1);
 489   EXPECT_FP_EQ(result, 4.0);
 490
 491   ret_val = LIBC_NAMESPACE::sscanf("-789", "%1f", &result);
 492   EXPECT_EQ(ret_val, 0);
 493
 494   ret_val = LIBC_NAMESPACE::sscanf("-123", "%2f", &result);
 495   EXPECT_EQ(ret_val, 1);
 496   EXPECT_FP_EQ(result, -1.0);
 497
 498   ret_val = LIBC_NAMESPACE::sscanf("inf", "%2f", &result);
 499   EXPECT_EQ(ret_val, 0);
 500
 501   ret_val = LIBC_NAMESPACE::sscanf("nan", "%1f", &result);
 502   EXPECT_EQ(ret_val, 0);
 503
 504   ret_val = LIBC_NAMESPACE::sscanf("-inf", "%3f", &result);
 505   EXPECT_EQ(ret_val, 0);
 506
 507   ret_val = LIBC_NAMESPACE::sscanf("-nan", "%3f", &result);
 508   EXPECT_EQ(ret_val, 0);
 509
 510   // If the max length were not here this would fail as discussed above, but
 511   // since the max length limits it to the 3 it succeeds.
 512   ret_val = LIBC_NAMESPACE::sscanf("infinite", "%3f", &result);
 513   EXPECT_EQ(ret_val, 1);
 514   EXPECT_FP_EQ(result, inf);
 515
 516   ret_val = LIBC_NAMESPACE::sscanf("-infinite", "%4f", &result);
 517   EXPECT_EQ(ret_val, 1);
 518   EXPECT_FP_EQ(result, -inf);
 519
 520   ret_val = LIBC_NAMESPACE::sscanf("01", "%1f", &result);
 521   EXPECT_EQ(ret_val, 1);
 522   EXPECT_FP_EQ(result, 0.0);
 523
 524   ret_val = LIBC_NAMESPACE::sscanf("0x1", "%2f", &result);
 525   EXPECT_EQ(ret_val, 1);
 526   EXPECT_FP_EQ(result, 0.0);
 527
 528   ret_val = LIBC_NAMESPACE::sscanf("100e", "%4f", &result);
 529   EXPECT_EQ(ret_val, 0);
 530
 531   ret_val = LIBC_NAMESPACE::sscanf("100e+10", "%5f", &result);
 532   EXPECT_EQ(ret_val, 0);
 533
 534   ret_val = LIBC_NAMESPACE::sscanf("100e10", "%5f", &result);
 535   EXPECT_EQ(ret_val, 1);
 536   EXPECT_FP_EQ(result, 100e1);
 537 }
 538
 539 TEST(LlvmLibcSScanfTest, FloatConvNoWrite) {
 540   int ret_val;
 541   float result = 0;
 542
 543   ret_val = LIBC_NAMESPACE::sscanf("123", "%*f", &result);
 544   EXPECT_EQ(ret_val, 1);
 545   EXPECT_FP_EQ(result, 0.0);
 546
 547   ret_val = LIBC_NAMESPACE::sscanf("456.1", "%*a", &result);
 548   EXPECT_EQ(ret_val, 1);
 549   EXPECT_FP_EQ(result, 0.0);
 550
 551   ret_val = LIBC_NAMESPACE::sscanf("0x789.ap0", "%*e", &result);
 552   EXPECT_EQ(ret_val, 1);
 553   EXPECT_FP_EQ(result, 0.0);
 554
 555   ret_val = LIBC_NAMESPACE::sscanf("+12.0e1", "%*g", &result);
 556   EXPECT_EQ(ret_val, 1);
 557   EXPECT_FP_EQ(result, 0.0);
 558
 559   ret_val = LIBC_NAMESPACE::sscanf("inf", "%*F", &result);
 560   EXPECT_EQ(ret_val, 1);
 561   EXPECT_FP_EQ(result, 0.0);
 562
 563   ret_val = LIBC_NAMESPACE::sscanf("NaN", "%*A", &result);
 564   EXPECT_EQ(ret_val, 1);
 565   EXPECT_FP_EQ(result, 0.0);
 566
 567   ret_val = LIBC_NAMESPACE::sscanf("-InFiNiTy", "%*E", &result);
 568   EXPECT_EQ(ret_val, 1);
 569   EXPECT_FP_EQ(result, 0.0);
 570
 571   ret_val = LIBC_NAMESPACE::sscanf("1e10", "%*G", &result);
 572   EXPECT_EQ(ret_val, 1);
 573   EXPECT_FP_EQ(result, 0.0);
 574
 575   ret_val = LIBC_NAMESPACE::sscanf(".1", "%*G", &result);
 576   EXPECT_EQ(ret_val, 1);
 577   EXPECT_FP_EQ(result, 0.0);
 578
 579   ret_val = LIBC_NAMESPACE::sscanf("123", "%*3f", &result);
 580   EXPECT_EQ(ret_val, 1);
 581   EXPECT_FP_EQ(result, 0.0);
 582
 583   ret_val = LIBC_NAMESPACE::sscanf("123", "%*5f", &result);
 584   EXPECT_EQ(ret_val, 1);
 585   EXPECT_FP_EQ(result, 0.0);
 586
 587   ret_val = LIBC_NAMESPACE::sscanf("456", "%*1f", &result);
 588   EXPECT_EQ(ret_val, 1);
 589   EXPECT_FP_EQ(result, 0.0);
 590
 591   ret_val = LIBC_NAMESPACE::sscanf("Not a float", "%*f", &result);
 592   EXPECT_EQ(ret_val, 0);
 593 }
 594 #endif
 595
 596 #ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 597 TEST(LlvmLibcSScanfTest, CurPosCombined) {
 598   int ret_val;
 599   int result = -1;
 600   char c_result = 0;
 601
 602   ret_val = LIBC_NAMESPACE::sscanf("some text", "%n", &result);
 603   // %n doesn't count as a conversion for the return value.
 604   EXPECT_EQ(ret_val, 0);
 605   EXPECT_EQ(result, 0);
 606
 607   ret_val = LIBC_NAMESPACE::sscanf("1234567890", "12345%n", &result);
 608   EXPECT_EQ(ret_val, 0);
 609   EXPECT_EQ(result, 5);
 610
 611   ret_val = LIBC_NAMESPACE::sscanf("1234567890", "12345%n", &result);
 612   EXPECT_EQ(ret_val, 0);
 613   EXPECT_EQ(result, 5);
 614
 615   // 288 characters
 616   ret_val = LIBC_NAMESPACE::sscanf("10000000000000000000000000000000"
 617                                    "00000000000000000000000000000000"
 618                                    "00000000000000000000000000000000"
 619                                    "00000000000000000000000000000000"
 620                                    "00000000000000000000000000000000"
 621                                    "00000000000000000000000000000000"
 622                                    "00000000000000000000000000000000"
 623                                    "00000000000000000000000000000000"
 624                                    "00000000000000000000000000000000",
 625                                    "%*d%hhn", &c_result);
 626   EXPECT_EQ(ret_val, 1);
 627   EXPECT_EQ(c_result, char(288)); // Overflow is handled by casting.
 628
 629   // 320 characters
 630   ret_val = LIBC_NAMESPACE::sscanf("10000000000000000000000000000000"
 631                                    "00000000000000000000000000000000"
 632                                    "00000000000000000000000000000000"
 633                                    "00000000000000000000000000000000"
 634                                    "00000000000000000000000000000000"
 635                                    "00000000000000000000000000000000"
 636                                    "00000000000000000000000000000000"
 637                                    "00000000000000000000000000000000"
 638                                    "00000000000000000000000000000000"
 639                                    "00000000000000000000000000000000",
 640                                    "%*d%n", &result);
 641   EXPECT_EQ(ret_val, 1);
 642   EXPECT_EQ(result, 320);
 643 }
 644 #endif
 645
 646 TEST(LlvmLibcSScanfTest, PointerConvCombined) {
 647   int ret_val;
 648   void *result;
 649
 650   ret_val = LIBC_NAMESPACE::sscanf("(nullptr)", "%p", &result);
 651   EXPECT_EQ(ret_val, 1);
 652   EXPECT_EQ(result, static_cast<void *>(nullptr));
 653
 654   ret_val = LIBC_NAMESPACE::sscanf("(NuLlPtR)", "%p", &result);
 655   EXPECT_EQ(ret_val, 1);
 656   EXPECT_EQ(result, static_cast<void *>(nullptr));
 657
 658   ret_val = LIBC_NAMESPACE::sscanf("(NULLPTR)", "%p", &result);
 659   EXPECT_EQ(ret_val, 1);
 660   EXPECT_EQ(result, static_cast<void *>(nullptr));
 661
 662   ret_val = LIBC_NAMESPACE::sscanf("(null)", "%p", &result);
 663   EXPECT_EQ(ret_val, 0);
 664
 665   ret_val = LIBC_NAMESPACE::sscanf("(nullptr2", "%p", &result);
 666   EXPECT_EQ(ret_val, 0);
 667
 668   ret_val = LIBC_NAMESPACE::sscanf("0", "%p", &result);
 669   EXPECT_EQ(ret_val, 1);
 670   EXPECT_EQ(result, reinterpret_cast<void *>(0));
 671
 672   ret_val = LIBC_NAMESPACE::sscanf("100", "%p", &result);
 673   EXPECT_EQ(ret_val, 1);
 674   EXPECT_EQ(result, reinterpret_cast<void *>(0x100));
 675
 676   ret_val = LIBC_NAMESPACE::sscanf("-1", "%p", &result);
 677   EXPECT_EQ(ret_val, 1);
 678   EXPECT_EQ(result, reinterpret_cast<void *>(-1));
 679
 680   ret_val = LIBC_NAMESPACE::sscanf("0xabcDEFG", "%p", &result);
 681   EXPECT_EQ(ret_val, 1);
 682   EXPECT_EQ(result, reinterpret_cast<void *>(0xabcdef));
 683 }
 684
 685 TEST(LlvmLibcSScanfTest, CombinedConv) {
 686   int ret_val;
 687   int result = 0;
 688   char buffer[10];
 689   ret_val = LIBC_NAMESPACE::sscanf("123abc", "%i%s", &result, buffer);
 690   EXPECT_EQ(ret_val, 2);
 691   EXPECT_EQ(result, 123);
 692   ASSERT_STREQ(buffer, "abc");
 693
 694   result = -1;
 695
 696   // 0x is a valid prefix, but not a valid number. This should be a matching
 697   // failure and should not modify the values.
 698   ret_val = LIBC_NAMESPACE::sscanf("0xZZZ", "%i%s", &result, buffer);
 699   EXPECT_EQ(ret_val, 0);
 700   EXPECT_EQ(result, -1);
 701   ASSERT_STREQ(buffer, "abc");
 702
 703   ret_val = LIBC_NAMESPACE::sscanf("0xZZZ", "%X%s", &result, buffer);
 704   EXPECT_EQ(ret_val, 0);
 705   EXPECT_EQ(result, -1);
 706   ASSERT_STREQ(buffer, "abc");
 707 }