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