libc/test/src/stdio/scanf_core/parser_test.cpp

   1 //===-- Unittests for the scanf Parser -----------------------------------===//
   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/bit.h"
  10 #include "src/__support/CPP/bitset.h"
  11 #include "src/__support/CPP/string_view.h"
  12 #include "src/__support/arg_list.h"
  13 #include "src/stdio/scanf_core/parser.h"
  14
  15 #include <stdarg.h>
  16
  17 #include "test/UnitTest/ScanfMatcher.h"
  18 #include "test/UnitTest/Test.h"
  19
  20 using __llvm_libc::cpp::string_view;
  21
  22 void init(const char *__restrict str, ...) {
  23   va_list vlist;
  24   va_start(vlist, str);
  25   __llvm_libc::internal::ArgList v(vlist);
  26   va_end(vlist);
  27
  28   __llvm_libc::scanf_core::Parser parser(str, v);
  29 }
  30
  31 void evaluate(__llvm_libc::scanf_core::FormatSection *format_arr,
  32               const char *__restrict str, ...) {
  33   va_list vlist;
  34   va_start(vlist, str);
  35   __llvm_libc::internal::ArgList v(vlist);
  36   va_end(vlist);
  37
  38   __llvm_libc::scanf_core::Parser parser(str, v);
  39
  40   for (auto cur_section = parser.get_next_section();
  41        !cur_section.raw_string.empty();
  42        cur_section = parser.get_next_section()) {
  43     *format_arr = cur_section;
  44     ++format_arr;
  45   }
  46 }
  47
  48 TEST(LlvmLibcScanfParserTest, Constructor) { init("test", 1, 2); }
  49
  50 TEST(LlvmLibcScanfParserTest, EvalRaw) {
  51   __llvm_libc::scanf_core::FormatSection format_arr[10];
  52   const char *str = "test";
  53   evaluate(format_arr, str);
  54
  55   __llvm_libc::scanf_core::FormatSection expected;
  56   expected.has_conv = false;
  57
  58   expected.raw_string = str;
  59
  60   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
  61   // TODO: add checks that the format_arr after the last one has length 0
  62 }
  63
  64 TEST(LlvmLibcScanfParserTest, EvalSimple) {
  65   __llvm_libc::scanf_core::FormatSection format_arr[10];
  66   const char *str = "test %% test";
  67   evaluate(format_arr, str);
  68
  69   __llvm_libc::scanf_core::FormatSection expected0, expected1, expected2;
  70   expected0.has_conv = false;
  71
  72   expected0.raw_string = {str, 5};
  73
  74   ASSERT_SFORMAT_EQ(expected0, format_arr[0]);
  75
  76   expected1.has_conv = true;
  77
  78   expected1.raw_string = {str + 5, 2};
  79   expected1.conv_name = '%';
  80
  81   ASSERT_SFORMAT_EQ(expected1, format_arr[1]);
  82
  83   expected2.has_conv = false;
  84
  85   expected2.raw_string = {str + 7, 5};
  86
  87   ASSERT_SFORMAT_EQ(expected2, format_arr[2]);
  88 }
  89
  90 TEST(LlvmLibcScanfParserTest, EvalOneArg) {
  91   __llvm_libc::scanf_core::FormatSection format_arr[10];
  92   const char *str = "%d";
  93   int arg1 = 12345;
  94   evaluate(format_arr, str, &arg1);
  95
  96   __llvm_libc::scanf_core::FormatSection expected;
  97   expected.has_conv = true;
  98
  99   expected.raw_string = str;
 100   expected.output_ptr = &arg1;
 101   expected.conv_name = 'd';
 102
 103   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 104 }
 105
 106 TEST(LlvmLibcScanfParserTest, EvalBadArg) {
 107   __llvm_libc::scanf_core::FormatSection format_arr[10];
 108   const char *str = "%\0abc";
 109   int arg1 = 12345;
 110   evaluate(format_arr, str, &arg1);
 111
 112   __llvm_libc::scanf_core::FormatSection expected;
 113   expected.has_conv = false;
 114   expected.raw_string = {str, 1};
 115
 116   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 117 }
 118
 119 TEST(LlvmLibcScanfParserTest, EvalOneArgWithFlag) {
 120   __llvm_libc::scanf_core::FormatSection format_arr[10];
 121   const char *str = "%*d";
 122   // Since NO_WRITE is set, the argument shouldn't be used, but I've included
 123   // one anyways because in the case that it doesn't work it's better for it to
 124   // have a real argument to check against.
 125   int arg1 = 12345;
 126   evaluate(format_arr, str, &arg1);
 127
 128   __llvm_libc::scanf_core::FormatSection expected;
 129   expected.has_conv = true;
 130
 131   expected.raw_string = str;
 132   expected.flags = __llvm_libc::scanf_core::FormatFlags::NO_WRITE;
 133   expected.conv_name = 'd';
 134
 135   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 136
 137   // If NO_WRITE is set, then the equality check ignores the pointer since it's
 138   // irrelevant, but in this case I want to make sure that it hasn't been set
 139   // and check it separately.
 140   ASSERT_EQ(expected.output_ptr, format_arr[0].output_ptr);
 141 }
 142
 143 TEST(LlvmLibcScanfParserTest, EvalOneArgWithWidth) {
 144   __llvm_libc::scanf_core::FormatSection format_arr[10];
 145   const char *str = "%12d";
 146   int arg1 = 12345;
 147   evaluate(format_arr, str, &arg1);
 148
 149   __llvm_libc::scanf_core::FormatSection expected;
 150   expected.has_conv = true;
 151
 152   expected.raw_string = str;
 153   expected.max_width = 12;
 154   expected.output_ptr = &arg1;
 155   expected.conv_name = 'd';
 156
 157   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 158 }
 159
 160 TEST(LlvmLibcScanfParserTest, EvalOneArgWithShortLengthModifier) {
 161   __llvm_libc::scanf_core::FormatSection format_arr[10];
 162   const char *str = "%hd";
 163   int arg1 = 12345;
 164   evaluate(format_arr, str, &arg1);
 165
 166   __llvm_libc::scanf_core::FormatSection expected;
 167   expected.has_conv = true;
 168
 169   expected.raw_string = str;
 170   expected.length_modifier = __llvm_libc::scanf_core::LengthModifier::h;
 171   expected.output_ptr = &arg1;
 172   expected.conv_name = 'd';
 173
 174   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 175 }
 176
 177 TEST(LlvmLibcScanfParserTest, EvalOneArgWithLongLengthModifier) {
 178   __llvm_libc::scanf_core::FormatSection format_arr[10];
 179   const char *str = "%lld";
 180   long long arg1 = 12345;
 181   evaluate(format_arr, str, &arg1);
 182
 183   __llvm_libc::scanf_core::FormatSection expected;
 184   expected.has_conv = true;
 185
 186   expected.raw_string = str;
 187   expected.length_modifier = __llvm_libc::scanf_core::LengthModifier::ll;
 188   expected.output_ptr = &arg1;
 189   expected.conv_name = 'd';
 190
 191   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 192 }
 193
 194 TEST(LlvmLibcScanfParserTest, EvalOneArgWithAllOptions) {
 195   __llvm_libc::scanf_core::FormatSection format_arr[10];
 196   const char *str = "%*56jd";
 197   intmax_t arg1 = 12345;
 198   evaluate(format_arr, str, &arg1);
 199
 200   __llvm_libc::scanf_core::FormatSection expected;
 201   expected.has_conv = true;
 202
 203   expected.raw_string = str;
 204   expected.flags = __llvm_libc::scanf_core::FormatFlags::NO_WRITE;
 205   expected.max_width = 56;
 206   expected.length_modifier = __llvm_libc::scanf_core::LengthModifier::j;
 207   expected.conv_name = 'd';
 208
 209   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 210 }
 211
 212 TEST(LlvmLibcScanfParserTest, EvalSimpleBracketArg) {
 213   __llvm_libc::scanf_core::FormatSection format_arr[10];
 214   const char *str = "%[abc]";
 215   char arg1 = 'a';
 216   evaluate(format_arr, str, &arg1);
 217
 218   __llvm_libc::scanf_core::FormatSection expected;
 219   expected.has_conv = true;
 220
 221   expected.raw_string = str;
 222   expected.conv_name = '[';
 223   expected.output_ptr = &arg1;
 224
 225   __llvm_libc::cpp::bitset<256> scan_set;
 226
 227   scan_set.set('a');
 228   scan_set.set('b');
 229   scan_set.set('c');
 230
 231   expected.scan_set = scan_set;
 232
 233   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 234 }
 235
 236 TEST(LlvmLibcScanfParserTest, EvalBracketArgRange) {
 237   __llvm_libc::scanf_core::FormatSection format_arr[10];
 238   const char *str = "%[A-D]";
 239   char arg1 = 'a';
 240   evaluate(format_arr, str, &arg1);
 241
 242   __llvm_libc::scanf_core::FormatSection expected;
 243   expected.has_conv = true;
 244
 245   expected.raw_string = str;
 246   expected.conv_name = '[';
 247   expected.output_ptr = &arg1;
 248
 249   __llvm_libc::cpp::bitset<256> scan_set;
 250
 251   scan_set.set('A');
 252   scan_set.set('B');
 253   scan_set.set('C');
 254   scan_set.set('D');
 255
 256   expected.scan_set = scan_set;
 257
 258   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 259 }
 260
 261 TEST(LlvmLibcScanfParserTest, EvalBracketArgTwoRanges) {
 262   __llvm_libc::scanf_core::FormatSection format_arr[10];
 263   const char *str = "%[A-De-g]";
 264   char arg1 = 'a';
 265   evaluate(format_arr, str, &arg1);
 266
 267   __llvm_libc::scanf_core::FormatSection expected;
 268   expected.has_conv = true;
 269
 270   expected.raw_string = str;
 271   expected.conv_name = '[';
 272   expected.output_ptr = &arg1;
 273
 274   __llvm_libc::cpp::bitset<256> scan_set;
 275
 276   scan_set.set('A');
 277   scan_set.set('B');
 278   scan_set.set('C');
 279   scan_set.set('D');
 280   scan_set.set_range('e', 'g');
 281
 282   expected.scan_set = scan_set;
 283
 284   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 285 }
 286
 287 TEST(LlvmLibcScanfParserTest, EvalBracketArgJustHyphen) {
 288   __llvm_libc::scanf_core::FormatSection format_arr[10];
 289   const char *str = "%[-]";
 290   char arg1 = 'a';
 291   evaluate(format_arr, str, &arg1);
 292
 293   __llvm_libc::scanf_core::FormatSection expected;
 294   expected.has_conv = true;
 295
 296   expected.raw_string = str;
 297   expected.conv_name = '[';
 298   expected.output_ptr = &arg1;
 299
 300   __llvm_libc::cpp::bitset<256> scan_set;
 301
 302   scan_set.set('-');
 303
 304   expected.scan_set = scan_set;
 305
 306   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 307 }
 308
 309 TEST(LlvmLibcScanfParserTest, EvalBracketArgLeftHyphen) {
 310   __llvm_libc::scanf_core::FormatSection format_arr[10];
 311   const char *str = "%[-A]";
 312   char arg1 = 'a';
 313   evaluate(format_arr, str, &arg1);
 314
 315   __llvm_libc::scanf_core::FormatSection expected;
 316   expected.has_conv = true;
 317
 318   expected.raw_string = str;
 319   expected.conv_name = '[';
 320   expected.output_ptr = &arg1;
 321
 322   __llvm_libc::cpp::bitset<256> scan_set;
 323
 324   scan_set.set('-');
 325   scan_set.set('A');
 326
 327   expected.scan_set = scan_set;
 328
 329   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 330 }
 331
 332 TEST(LlvmLibcScanfParserTest, EvalBracketArgRightHyphen) {
 333   __llvm_libc::scanf_core::FormatSection format_arr[10];
 334   const char *str = "%[Z-]";
 335   char arg1 = 'a';
 336   evaluate(format_arr, str, &arg1);
 337
 338   __llvm_libc::scanf_core::FormatSection expected;
 339   expected.has_conv = true;
 340
 341   expected.raw_string = str;
 342   expected.conv_name = '[';
 343   expected.output_ptr = &arg1;
 344
 345   __llvm_libc::cpp::bitset<256> scan_set;
 346
 347   scan_set.set('-');
 348   scan_set.set('Z');
 349
 350   expected.scan_set = scan_set;
 351
 352   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 353 }
 354
 355 TEST(LlvmLibcScanfParserTest, EvalBracketArgInvertSimple) {
 356   __llvm_libc::scanf_core::FormatSection format_arr[10];
 357   const char *str = "%[^abc]";
 358   char arg1 = 'a';
 359   evaluate(format_arr, str, &arg1);
 360
 361   __llvm_libc::scanf_core::FormatSection expected;
 362   expected.has_conv = true;
 363
 364   expected.raw_string = str;
 365   expected.conv_name = '[';
 366   expected.output_ptr = &arg1;
 367
 368   __llvm_libc::cpp::bitset<256> scan_set;
 369
 370   scan_set.set('a');
 371   scan_set.set('b');
 372   scan_set.set('c');
 373   scan_set.flip();
 374
 375   expected.scan_set = scan_set;
 376
 377   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 378 }
 379
 380 TEST(LlvmLibcScanfParserTest, EvalBracketArgInvertRange) {
 381   __llvm_libc::scanf_core::FormatSection format_arr[10];
 382   const char *str = "%[^0-9]";
 383   char arg1 = 'a';
 384   evaluate(format_arr, str, &arg1);
 385
 386   __llvm_libc::scanf_core::FormatSection expected;
 387   expected.has_conv = true;
 388
 389   expected.raw_string = str;
 390   expected.conv_name = '[';
 391   expected.output_ptr = &arg1;
 392
 393   __llvm_libc::cpp::bitset<256> scan_set;
 394
 395   scan_set.set_range('0', '9');
 396   scan_set.flip();
 397
 398   expected.scan_set = scan_set;
 399
 400   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 401 }
 402
 403 TEST(LlvmLibcScanfParserTest, EvalBracketArgRightBracket) {
 404   __llvm_libc::scanf_core::FormatSection format_arr[10];
 405   const char *str = "%[]]";
 406   char arg1 = 'a';
 407   evaluate(format_arr, str, &arg1);
 408
 409   __llvm_libc::scanf_core::FormatSection expected;
 410   expected.has_conv = true;
 411
 412   expected.raw_string = str;
 413   expected.conv_name = '[';
 414   expected.output_ptr = &arg1;
 415
 416   __llvm_libc::cpp::bitset<256> scan_set;
 417
 418   scan_set.set(']');
 419
 420   expected.scan_set = scan_set;
 421
 422   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 423 }
 424
 425 TEST(LlvmLibcScanfParserTest, EvalBracketArgRightBracketRange) {
 426   __llvm_libc::scanf_core::FormatSection format_arr[10];
 427   const char *str = "%[]-a]";
 428   char arg1 = 'a';
 429   evaluate(format_arr, str, &arg1);
 430
 431   __llvm_libc::scanf_core::FormatSection expected;
 432   expected.has_conv = true;
 433
 434   expected.raw_string = str;
 435   expected.conv_name = '[';
 436   expected.output_ptr = &arg1;
 437
 438   __llvm_libc::cpp::bitset<256> scan_set;
 439
 440   scan_set.set_range(']', 'a');
 441
 442   expected.scan_set = scan_set;
 443
 444   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 445 }
 446
 447 TEST(LlvmLibcScanfParserTest, EvalBracketArgRightBracketInvert) {
 448   __llvm_libc::scanf_core::FormatSection format_arr[10];
 449   const char *str = "%[^]]";
 450   char arg1 = 'a';
 451   evaluate(format_arr, str, &arg1);
 452
 453   __llvm_libc::scanf_core::FormatSection expected;
 454   expected.has_conv = true;
 455
 456   expected.raw_string = str;
 457   expected.conv_name = '[';
 458   expected.output_ptr = &arg1;
 459
 460   __llvm_libc::cpp::bitset<256> scan_set;
 461
 462   scan_set.set(']');
 463   scan_set.flip();
 464
 465   expected.scan_set = scan_set;
 466
 467   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 468 }
 469
 470 TEST(LlvmLibcScanfParserTest, EvalBracketArgRightBracketInvertRange) {
 471   __llvm_libc::scanf_core::FormatSection format_arr[10];
 472   const char *str = "%[^]-^]";
 473   char arg1 = 'a';
 474   evaluate(format_arr, str, &arg1);
 475
 476   __llvm_libc::scanf_core::FormatSection expected;
 477   expected.has_conv = true;
 478
 479   expected.raw_string = str;
 480   expected.conv_name = '[';
 481   expected.output_ptr = &arg1;
 482
 483   __llvm_libc::cpp::bitset<256> scan_set;
 484
 485   scan_set.set_range(']', '^');
 486   scan_set.flip();
 487
 488   expected.scan_set = scan_set;
 489
 490   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 491 }
 492
 493 // This is not part of the standard, but the hyphen's effect is always
 494 // implementation defined, and I have defined it such that it will capture the
 495 // correct range regardless of the order of the characters.
 496 TEST(LlvmLibcScanfParserTest, EvalBracketArgBackwardsRange) {
 497   __llvm_libc::scanf_core::FormatSection format_arr[10];
 498   const char *str = "%[9-0]";
 499   char arg1 = 'a';
 500   evaluate(format_arr, str, &arg1);
 501
 502   __llvm_libc::scanf_core::FormatSection expected;
 503   expected.has_conv = true;
 504
 505   expected.raw_string = str;
 506   expected.conv_name = '[';
 507   expected.output_ptr = &arg1;
 508
 509   __llvm_libc::cpp::bitset<256> scan_set;
 510
 511   scan_set.set_range('0', '9');
 512
 513   expected.scan_set = scan_set;
 514
 515   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 516 }
 517
 518 TEST(LlvmLibcScanfParserTest, EvalThreeArgs) {
 519   __llvm_libc::scanf_core::FormatSection format_arr[10];
 520   const char *str = "%d%f%s";
 521   int arg1 = 12345;
 522   double arg2 = 123.45;
 523   const char *arg3 = "12345";
 524   evaluate(format_arr, str, &arg1, &arg2, &arg3);
 525
 526   __llvm_libc::scanf_core::FormatSection expected0, expected1, expected2;
 527   expected0.has_conv = true;
 528
 529   expected0.raw_string = {str, 2};
 530   expected0.output_ptr = &arg1;
 531   expected0.conv_name = 'd';
 532
 533   ASSERT_SFORMAT_EQ(expected0, format_arr[0]);
 534
 535   expected1.has_conv = true;
 536
 537   expected1.raw_string = {str + 2, 2};
 538   expected1.output_ptr = &arg2;
 539   expected1.conv_name = 'f';
 540
 541   ASSERT_SFORMAT_EQ(expected1, format_arr[1]);
 542
 543   expected2.has_conv = true;
 544
 545   expected2.raw_string = {str + 4, 2};
 546   expected2.output_ptr = &arg3;
 547   expected2.conv_name = 's';
 548
 549   ASSERT_SFORMAT_EQ(expected2, format_arr[2]);
 550 }
 551
 552 #ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 553
 554 TEST(LlvmLibcScanfParserTest, IndexModeOneArg) {
 555   __llvm_libc::scanf_core::FormatSection format_arr[10];
 556   const char *str = "%1$d";
 557   int arg1 = 12345;
 558   evaluate(format_arr, str, &arg1);
 559
 560   __llvm_libc::scanf_core::FormatSection expected;
 561   expected.has_conv = true;
 562
 563   expected.raw_string = {str, 4};
 564   expected.output_ptr = &arg1;
 565   expected.conv_name = 'd';
 566
 567   ASSERT_SFORMAT_EQ(expected, format_arr[0]);
 568 }
 569
 570 TEST(LlvmLibcScanfParserTest, IndexModeThreeArgsSequential) {
 571   __llvm_libc::scanf_core::FormatSection format_arr[10];
 572   const char *str = "%1$d%2$f%3$s";
 573   int arg1 = 12345;
 574   double arg2 = 123.45;
 575   const char *arg3 = "12345";
 576   evaluate(format_arr, str, &arg1, &arg2, &arg3);
 577
 578   __llvm_libc::scanf_core::FormatSection expected0, expected1, expected2;
 579   expected0.has_conv = true;
 580
 581   expected0.raw_string = {str, 4};
 582   expected0.output_ptr = &arg1;
 583   expected0.conv_name = 'd';
 584
 585   ASSERT_SFORMAT_EQ(expected0, format_arr[0]);
 586
 587   expected1.has_conv = true;
 588
 589   expected1.raw_string = {str + 4, 4};
 590   expected1.output_ptr = &arg2;
 591   expected1.conv_name = 'f';
 592
 593   ASSERT_SFORMAT_EQ(expected1, format_arr[1]);
 594
 595   expected2.has_conv = true;
 596
 597   expected2.raw_string = {str + 8, 4};
 598   expected2.output_ptr = &arg3;
 599   expected2.conv_name = 's';
 600
 601   ASSERT_SFORMAT_EQ(expected2, format_arr[2]);
 602 }
 603
 604 TEST(LlvmLibcScanfParserTest, IndexModeThreeArgsReverse) {
 605   __llvm_libc::scanf_core::FormatSection format_arr[10];
 606   const char *str = "%3$d%2$f%1$s";
 607   int arg1 = 12345;
 608   double arg2 = 123.45;
 609   const char *arg3 = "12345";
 610   evaluate(format_arr, str, &arg3, &arg2, &arg1);
 611
 612   __llvm_libc::scanf_core::FormatSection expected0, expected1, expected2;
 613   expected0.has_conv = true;
 614
 615   expected0.raw_string = {str, 4};
 616   expected0.output_ptr = &arg1;
 617   expected0.conv_name = 'd';
 618
 619   ASSERT_SFORMAT_EQ(expected0, format_arr[0]);
 620
 621   expected1.has_conv = true;
 622
 623   expected1.raw_string = {str + 4, 4};
 624   expected1.output_ptr = &arg2;
 625   expected1.conv_name = 'f';
 626
 627   ASSERT_SFORMAT_EQ(expected1, format_arr[1]);
 628
 629   expected2.has_conv = true;
 630
 631   expected2.raw_string = {str + 8, 4};
 632   expected2.output_ptr = &arg3;
 633   expected2.conv_name = 's';
 634
 635   ASSERT_SFORMAT_EQ(expected2, format_arr[2]);
 636 }
 637
 638 TEST(LlvmLibcScanfParserTest, IndexModeTenArgsRandom) {
 639   __llvm_libc::scanf_core::FormatSection format_arr[10];
 640   const char *str = "%6$d%3$d%7$d%2$d%8$d%1$d%4$d%9$d%5$d%10$d";
 641   uintptr_t args[10] = {6, 4, 2, 7, 9, 1, 3, 5, 8, 10};
 642   evaluate(format_arr, str, args[0], args[1], args[2], args[3], args[4],
 643            args[5], args[6], args[7], args[8], args[9]);
 644
 645   for (size_t i = 0; i < 10; ++i) {
 646     __llvm_libc::scanf_core::FormatSection expected;
 647     expected.has_conv = true;
 648
 649     expected.raw_string = {str + (4 * i),
 650                            static_cast<size_t>(4 + (i >= 9 ? 1 : 0))};
 651     expected.output_ptr = reinterpret_cast<void *>(i + 1);
 652     expected.conv_name = 'd';
 653     EXPECT_SFORMAT_EQ(expected, format_arr[i]);
 654   }
 655 }
 656
 657 TEST(LlvmLibcScanfParserTest, IndexModeComplexParsing) {
 658   __llvm_libc::scanf_core::FormatSection format_arr[11];
 659   const char *str = "normal text %3$llu %% %2$*f %4$d %1$1c%5$[123]";
 660   char arg1 = '1';
 661   double arg2 = 123.45;
 662   unsigned long long arg3 = 12345;
 663   int arg4 = 10;
 664   char arg5 = 'A';
 665   evaluate(format_arr, str, &arg1, &arg2, &arg3, &arg4, &arg5);
 666
 667   __llvm_libc::scanf_core::FormatSection expected0, expected1, expected2,
 668       expected3, expected4, expected5, expected6, expected7, expected8,
 669       expected9, expected10;
 670
 671   expected0.has_conv = false;
 672
 673   // "normal text "
 674   expected0.raw_string = {str, 12};
 675
 676   EXPECT_SFORMAT_EQ(expected0, format_arr[0]);
 677
 678   expected1.has_conv = true;
 679   // "%3$llu"
 680   expected1.raw_string = {str + 12, 6};
 681   expected1.length_modifier = __llvm_libc::scanf_core::LengthModifier::ll;
 682   expected1.output_ptr = &arg3;
 683   expected1.conv_name = 'u';
 684
 685   EXPECT_SFORMAT_EQ(expected1, format_arr[1]);
 686
 687   expected2.has_conv = false;
 688   // " "
 689   expected2.raw_string = {str + 18, 1};
 690
 691   EXPECT_SFORMAT_EQ(expected2, format_arr[2]);
 692
 693   expected3.has_conv = true;
 694   // "%%"
 695   expected3.raw_string = {str + 19, 2};
 696   expected3.conv_name = '%';
 697
 698   EXPECT_SFORMAT_EQ(expected3, format_arr[3]);
 699
 700   expected4.has_conv = false;
 701   // " "
 702   expected4.raw_string = {str + 21, 1};
 703
 704   EXPECT_SFORMAT_EQ(expected4, format_arr[4]);
 705
 706   expected5.has_conv = true;
 707   // "%2$*f"
 708   expected5.raw_string = {str + 22, 5};
 709   expected5.flags = __llvm_libc::scanf_core::FormatFlags::NO_WRITE;
 710   expected5.conv_name = 'f';
 711
 712   EXPECT_SFORMAT_EQ(expected5, format_arr[5]);
 713
 714   expected6.has_conv = false;
 715   // " "
 716   expected6.raw_string = {str + 27, 1};
 717
 718   EXPECT_SFORMAT_EQ(expected6, format_arr[6]);
 719
 720   expected7.has_conv = true;
 721
 722   // "%4$d"
 723   expected7.raw_string = {str + 28, 4};
 724   expected7.output_ptr = &arg4;
 725   expected7.conv_name = 'd';
 726
 727   EXPECT_SFORMAT_EQ(expected7, format_arr[7]);
 728
 729   expected8.has_conv = false;
 730   // " "
 731   expected8.raw_string = {str + 32, 1};
 732
 733   EXPECT_SFORMAT_EQ(expected8, format_arr[8]);
 734
 735   expected9.has_conv = true;
 736   // "%1$1c"
 737   expected9.raw_string = {str + 33, 5};
 738   expected9.max_width = 1;
 739   expected9.output_ptr = &arg1;
 740   expected9.conv_name = 'c';
 741
 742   EXPECT_SFORMAT_EQ(expected9, format_arr[9]);
 743
 744   expected10.has_conv = true;
 745   // "%5$[123]"
 746   expected10.raw_string = {str + 38, 8};
 747   expected10.output_ptr = &arg5;
 748   expected10.conv_name = '[';
 749
 750   __llvm_libc::cpp::bitset<256> scan_set;
 751
 752   scan_set.set_range('1', '3');
 753
 754   expected10.scan_set = scan_set;
 755
 756   EXPECT_SFORMAT_EQ(expected10, format_arr[10]);
 757 }
 758
 759 #endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE