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