708 lines · 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-exception6//7//===----------------------------------------------------------------------===//8 9#include "src/stdio/sscanf.h"10 11#include "hdr/stdio_macros.h" // For EOF12#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 17TEST(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 36TEST(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 characters60 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 77TEST(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 handling88 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^15120 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 136TEST(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 156TEST(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 matching183 // 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 213TEST(LlvmLibcSScanfTest, IntConvNoWriteTests) {214 int ret_val;215 // Result shouldn't be used by these tests, but it's safer to have it and216 // 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_FLOAT240TEST(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.0f);250 251 ret_val = LIBC_NAMESPACE::sscanf("456.1", "%a", &result);252 EXPECT_EQ(ret_val, 1);253 EXPECT_FP_EQ(result, 456.1f);254 255 ret_val = LIBC_NAMESPACE::sscanf("0x789.ap0", "%e", &result);256 EXPECT_EQ(ret_val, 1);257 EXPECT_FP_EQ(result, 0x789.ap0f);258 259 ret_val = LIBC_NAMESPACE::sscanf("0x.8", "%e", &result);260 EXPECT_EQ(ret_val, 1);261 EXPECT_FP_EQ(result, 0x0.8p0f);262 263 ret_val = LIBC_NAMESPACE::sscanf("0x8.", "%e", &result);264 EXPECT_EQ(ret_val, 1);265 EXPECT_FP_EQ(result, 0x8.0p0f);266 267 ret_val = LIBC_NAMESPACE::sscanf("+12.0e1", "%g", &result);268 EXPECT_EQ(ret_val, 1);269 EXPECT_FP_EQ(result, 12.0e1f);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, 1e10f);286 287 ret_val = LIBC_NAMESPACE::sscanf(".1", "%G", &result);288 EXPECT_EQ(ret_val, 1);289 EXPECT_FP_EQ(result, 0.1f);290 291 ret_val = LIBC_NAMESPACE::sscanf("1.", "%G", &result);292 EXPECT_EQ(ret_val, 1);293 EXPECT_FP_EQ(result, 1.0f);294 295 ret_val = LIBC_NAMESPACE::sscanf("0", "%f", &result);296 EXPECT_EQ(ret_val, 1);297 EXPECT_FP_EQ(result, 0.0f);298 299 ret_val = LIBC_NAMESPACE::sscanf("Not a float", "%f", &result);300 EXPECT_EQ(ret_val, 0);301}302 303TEST(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_FLOAT64337 EXPECT_FP_EQ(ld_result, d_inf);338#else339 EXPECT_FP_EQ(ld_result, 1.0e600L);340#endif341}342 343TEST(LlvmLibcSScanfTest, FloatConvLongNumber) {344 int ret_val;345 float result = 0;346 double d_result = 0;347 348 // 32 characters349 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 characters355 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 characters364 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 characters374 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 characters387 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 401TEST(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.0e3p0f);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 from428 // 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" or451 // "infinity" when it stops. It only stops when it encounters a character that452 // isn't the next one in the string, so it accepts "infi" as the the longest453 // prefix of a possibly valid floating-point number, but determines that it is454 // not valid and returns a matching failure. This is because it can only unget455 // one character so when it finds that the character after the second 'i' is456 // not the next character in "infinity" it can't rewind to the point where it457 // 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, -.1e1f);467 468 ret_val = LIBC_NAMESPACE::sscanf("1.2.e1", "%f", &result);469 EXPECT_EQ(ret_val, 1);470 EXPECT_FP_EQ(result, 1.2f);471}472 473TEST(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.0f);482 483 ret_val = LIBC_NAMESPACE::sscanf("123", "%5f", &result);484 EXPECT_EQ(ret_val, 1);485 EXPECT_FP_EQ(result, 123.0f);486 487 ret_val = LIBC_NAMESPACE::sscanf("456", "%1f", &result);488 EXPECT_EQ(ret_val, 1);489 EXPECT_FP_EQ(result, 4.0f);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.0f);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, but511 // 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.0f);523 524 ret_val = LIBC_NAMESPACE::sscanf("0x1", "%2f", &result);525 EXPECT_EQ(ret_val, 1);526 EXPECT_FP_EQ(result, 0.0f);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, 100e1f);537}538 539TEST(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.0f);546 547 ret_val = LIBC_NAMESPACE::sscanf("456.1", "%*a", &result);548 EXPECT_EQ(ret_val, 1);549 EXPECT_FP_EQ(result, 0.0f);550 551 ret_val = LIBC_NAMESPACE::sscanf("0x789.ap0", "%*e", &result);552 EXPECT_EQ(ret_val, 1);553 EXPECT_FP_EQ(result, 0.0f);554 555 ret_val = LIBC_NAMESPACE::sscanf("+12.0e1", "%*g", &result);556 EXPECT_EQ(ret_val, 1);557 EXPECT_FP_EQ(result, 0.0f);558 559 ret_val = LIBC_NAMESPACE::sscanf("inf", "%*F", &result);560 EXPECT_EQ(ret_val, 1);561 EXPECT_FP_EQ(result, 0.0f);562 563 ret_val = LIBC_NAMESPACE::sscanf("NaN", "%*A", &result);564 EXPECT_EQ(ret_val, 1);565 EXPECT_FP_EQ(result, 0.0f);566 567 ret_val = LIBC_NAMESPACE::sscanf("-InFiNiTy", "%*E", &result);568 EXPECT_EQ(ret_val, 1);569 EXPECT_FP_EQ(result, 0.0f);570 571 ret_val = LIBC_NAMESPACE::sscanf("1e10", "%*G", &result);572 EXPECT_EQ(ret_val, 1);573 EXPECT_FP_EQ(result, 0.0f);574 575 ret_val = LIBC_NAMESPACE::sscanf(".1", "%*G", &result);576 EXPECT_EQ(ret_val, 1);577 EXPECT_FP_EQ(result, 0.0f);578 579 ret_val = LIBC_NAMESPACE::sscanf("123", "%*3f", &result);580 EXPECT_EQ(ret_val, 1);581 EXPECT_FP_EQ(result, 0.0f);582 583 ret_val = LIBC_NAMESPACE::sscanf("123", "%*5f", &result);584 EXPECT_EQ(ret_val, 1);585 EXPECT_FP_EQ(result, 0.0f);586 587 ret_val = LIBC_NAMESPACE::sscanf("456", "%*1f", &result);588 EXPECT_EQ(ret_val, 1);589 EXPECT_FP_EQ(result, 0.0f);590 591 ret_val = LIBC_NAMESPACE::sscanf("Not a float", "%*f", &result);592 EXPECT_EQ(ret_val, 0);593}594#endif595 596#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE597TEST(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 characters616 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 characters630 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#endif645 646TEST(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 685TEST(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 matching697 // 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}708