pd.if.org Git - pdclib/blob - functions/stdio/scanf_testcases.incl

   1     // -----------------------------------------------------------------------
   2     // Literal matching
   3     // -----------------------------------------------------------------------
   4     {
   5     // matching six characters literally
   6     // should report six characters read
   7     TESTSCAN( 0, 6, general, 0, "123456" );
   8     }
   9     {
  10     // matching a character, three whitespace chars, and another character
  11     // should report five characters read
  12     TESTSCAN( 0, 5, general, 30, "1 5" );
  13     }
  14     {
  15     // matching three characters, not matching whitespaces, and matching another three characters
  16     // should report six characters matched
  17     TESTSCAN( 0, 6, general, 0, "123  456" );
  18     }
  19     {
  20     // matching a character, two '%' characters, and two whitespaces
  21     // should report five characters matched
  22     TESTSCAN( 0, 5, general, 34, "5%%%% " );
  23     }
  24     {
  25     // seeking to last character in file, trying to match that char and a whitespace
  26     // should report one character matched and EOF
  27     TESTSCAN( 0, 1, general, 39, "0 " );
  28     }
  29     {
  30     // seeking to end of file, trying to match a -1
  31     // should report error, not executing %n
  32     TESTSCAN( 0, 1, general, 40, "\377" );
  33     }
  34
  35     // -----------------------------------------------------------------------
  36     // Character matching ('%c')
  37     // -----------------------------------------------------------------------
  38     {
  39     // reading a char array of specified width, including zero bytes
  40     // should report the characters read up to first zero
  41     char buffer[ 8 ];
  42     memset( buffer, '\177', 8 );
  43     TESTSCAN( 1, 1, general, 10, "%7c", buffer );
  44     CHECK_FALSE( memcmp( buffer, "1\177\177", 3 ) );
  45     }
  46     {
  47     // reading a char array of unspecified width when positioned at -1 value
  48     // should default to width one, read the -1 value, no zero termination of the array
  49     char buffer[ 2 ];
  50     memset( buffer, '\177', 2 );
  51     TESTSCAN( 1, 1, general, 19, "%c", buffer );
  52     CHECK_FALSE( memcmp( buffer, "\377\177", 2 ) );
  53     }
  54     {
  55     // reading a char array of specified width 1 when positioned at (non-space) whitespace
  56     // should read the whitespace (literally), no zero termination of the array
  57     char buffer[ 2 ];
  58     memset( buffer, '\177', 2 );
  59     TESTSCAN( 1, 1, general, 32, "%1c", buffer );
  60     CHECK_FALSE( memcmp( buffer, "\011\177", 2 ) );
  61     }
  62     {
  63     // reading a char array of specified width 2 when positioned at last char of file
  64     // should read the character, and report EOF
  65     char buffer[ 2 ];
  66     memset( buffer, '\177', 2 );
  67     TESTSCAN( 1, 1, general, 39, "%2c", buffer );
  68     CHECK_FALSE( memcmp( buffer, "0\177", 2 ) );
  69     }
  70     {
  71     // reading a char array of specified width 1 when positioned at last char of file
  72     // should read the character, and NOT report EOF
  73     char buffer[ 2 ];
  74     memset( buffer, '\177', 2 );
  75     TESTSCAN( 1, 1, general, 39, "%1c", buffer );
  76     CHECK_FALSE( memcmp( buffer, "0\177", 2 ) );
  77     }
  78     {
  79     // reading a char array of specified width 1 when positioned at EOF
  80     // should report input error before any conversion (-1)
  81     char buffer[ 2 ];
  82     memset( buffer, '\177', 2 );
  83     TESTSCAN( -1, -1, general, 40, "%1c", buffer );
  84     CHECK_FALSE( memcmp( buffer, "\177\177", 2 ) );
  85     }
  86
  87     // -----------------------------------------------------------------------
  88     // Integer matching ('%d')
  89     // -----------------------------------------------------------------------
  90     {
  91     // reading a whitespace-terminated integer
  92     int i;
  93     TESTSCAN( 1, 1, general, 20, "%d", &i );
  94     CHECK_EQUAL( i, 2 );
  95     }
  96     {
  97     // reading a -1 terminated integer
  98     int i;
  99     TESTSCAN( 1, 1, general, 18, "%d", &i );
 100     CHECK_EQUAL( i, 9 );
 101     }
 102     {
 103     // reading a EOF terminated integer
 104     int i = -1;
 105     TESTSCAN( 1, 1, general, 39, "%d", &i );
 106     CHECK_EQUAL( i, 0 );
 107     }
 108     {
 109     // trying to read an integer when positioned at whitespace
 110     // should skip whitespaces
 111     int i = -1;
 112     TESTSCAN( 1, 3, general, 32, "%d", &i );
 113     CHECK_EQUAL( i, 5 );
 114     }
 115     {
 116     // trying to read an integer when positioned at -1 value
 117     // should report matching failure
 118     int i = 0;
 119     TESTSCAN( 0, -1, general, 19, "%d", &i, &n ), 0 );
 120     CHECK_EQUAL( i, 0 );
 121     }
 122     {
 123     // trying to read an integer when positioned at EOF
 124     // should report reading failure
 125     int i = 0;
 126     TESTSCAN( -1, -1, general, 40, "%d", &i, &n ), -1 );
 127     CHECK_EQUAL( i, 0 );
 128     }
 129     {
 130     // reading a '-'-prefixed integer
 131     int i;
 132     TESTSCAN( 1, 2, general, 13, "%d", &i );
 133     CHECK_EQUAL( i, -5 );
 134     }
 135     {
 136     // reading a '+'-prefixed integer
 137     int i;
 138     TESTSCAN( 1, 2, general, 15, "%d", &i );
 139     CHECK_EQUAL( i, 7 );
 140     }
 141
 142     // decimal integer matches
 143     {
 144     // reading 0, d
 145     signed char i = -1;
 146     TESTSCAN( 1, 1, decimal, 1, "%hhd", &i );
 147     CHECK_EQUAL( i, 0 );
 148     }
 149     {
 150     // reading -0, d
 151     signed char i = -1;
 152     TESTSCAN( 1, 2, decimal, 0, "%hhd", &i );
 153     CHECK_EQUAL( i, 0 );
 154     }
 155     {
 156     // reading +0, d
 157     signed char i = -1;
 158     TESTSCAN( 1, 2, decimal, 3, "%hhd", &i );
 159     CHECK_EQUAL( i, 0 );
 160     }
 161     {
 162     // reading -128, d
 163     signed char i = -1;
 164     TESTSCAN( 1, 4, decimal, 6, "%hhd", &i );
 165     CHECK_EQUAL( i, -128 );
 166     }
 167     {
 168     // reading 127, d
 169     signed char i = -1;
 170     TESTSCAN( 1, 3, decimal, 12, "%hhd", &i );
 171     CHECK_EQUAL( i, 127 );
 172     }
 173     {
 174     // reading +127, d
 175     signed char i = -1;
 176     TESTSCAN( 1, 4, decimal, 11, "%hhd", &i );
 177     CHECK_EQUAL( i, 127 );
 178     }
 179     {
 180     // reading 0, u
 181     unsigned char i = -1;
 182     TESTSCAN( 1, 1, decimal, 1, "%hhu", &i );
 183     CHECK_EQUAL( i, 0 );
 184     }
 185     {
 186     // reading -0, u
 187     unsigned char i = -1;
 188     TESTSCAN( 1, 2, decimal, 0, "%hhu", &i );
 189     CHECK_EQUAL( i, 0 );
 190     }
 191     {
 192     // reading +0, u
 193     unsigned char i = -1;
 194     TESTSCAN( 1, 2, decimal, 3, "%hhu", &i );
 195     CHECK_EQUAL( i, 0 );
 196     }
 197     {
 198     // reading 127, u
 199     unsigned char i = -1;
 200     TESTSCAN( 1, 3, decimal, 12, "%hhu", &i );
 201     CHECK_EQUAL( i, 127 );
 202     }
 203     {
 204     // reading +127, u
 205     unsigned char i = -1;
 206     TESTSCAN( 1, 4, decimal, 11, "%hhu", &i );
 207     CHECK_EQUAL( i, 127 );
 208     }
 209     {
 210     // reading 255, u
 211     unsigned char i = 0;
 212     TESTSCAN( 1, 3, decimal, 17, "%hhu", &i );
 213     CHECK_EQUAL( i, 255 );
 214     }
 215     {
 216     // reading +255, u
 217     unsigned char i = 0;
 218     TESTSCAN( 1, 4, decimal, 16, "%hhu", &i );
 219     CHECK_EQUAL( i, 255 );
 220     }
 221     {
 222     // reading 0, i
 223     signed char i = -1;
 224     TESTSCAN( 1, 1, decimal, 1, "%hhi", &i );
 225     CHECK_EQUAL( i, 0 );
 226     }
 227     {
 228     // reading -0, i
 229     signed char i = -1;
 230     TESTSCAN( 1, 2, decimal, 0, "%hhi", &i );
 231     CHECK_EQUAL( i, 0 );
 232     }
 233     {
 234     // reading +0, i
 235     signed char i = -1;
 236     TESTSCAN( 1, 2, decimal, 3, "%hhi", &i );
 237     CHECK_EQUAL( i, 0 );
 238     }
 239     {
 240     // reading -128, i
 241     signed char i = -1;
 242     TESTSCAN( 1, 4, decimal, 6, "%hhi", &i );
 243     CHECK_EQUAL( i, -128 );
 244     }
 245     {
 246     // reading 127, i
 247     signed char i = -1;
 248     TESTSCAN( 1, 3, decimal, 12, "%hhi", &i );
 249     CHECK_EQUAL( i, 127 );
 250     }
 251     {
 252     // reading +127, i
 253     signed char i = -1;
 254     TESTSCAN( 1, 4, decimal, 11, "%hhi", &i );
 255     CHECK_EQUAL( i, 127 );
 256     }
 257     {
 258     // reading 0, d
 259     signed short i = -1;
 260     TESTSCAN( 1, 1, decimal, 1, "%hd", &i );
 261     CHECK_EQUAL( i, 0 );
 262     }
 263     {
 264     // reading -0, d
 265     signed short i = -1;
 266     TESTSCAN( 1, 2, decimal, 0, "%hd", &i );
 267     CHECK_EQUAL( i, 0 );
 268     }
 269     {
 270     // reading +0, d
 271     signed short i = -1;
 272     TESTSCAN( 1, 2, decimal, 3, "%hd", &i );
 273     CHECK_EQUAL( i, 0 );
 274     }
 275     {
 276     // reading -32768, d
 277     signed short i = -1;
 278     TESTSCAN( 1, 6, decimal, 21, "%hd", &i );
 279     CHECK_EQUAL( i, -32768 );
 280     }
 281     {
 282     // reading 32767, d
 283     signed short i = -1;
 284     TESTSCAN( 1, 5, decimal, 29, "%hd", &i );
 285     CHECK_EQUAL( i, 32767 );
 286     }
 287     {
 288     // reading +32767, d
 289     signed short i = -1;
 290     TESTSCAN( 1, 6, decimal, 28, "%hd", &i );
 291     CHECK_EQUAL( i, 32767 );
 292     }
 293     {
 294     // reading 0, u
 295     unsigned short i = -1;
 296     TESTSCAN( 1, 1, decimal, 1, "%hu", &i );
 297     CHECK_EQUAL( i, 0 );
 298     }
 299     {
 300     // reading -0, u
 301     unsigned short i = -1;
 302     TESTSCAN( 1, 2, decimal, 0, "%hu", &i );
 303     CHECK_EQUAL( i, 0 );
 304     }
 305     {
 306     // reading +0, u
 307     unsigned short i = -1;
 308     TESTSCAN( 1, 2, decimal, 3, "%hu", &i );
 309     CHECK_EQUAL( i, 0 );
 310     }
 311     {
 312     // reading 32767, u
 313     unsigned short i = -1;
 314     TESTSCAN( 1, 5, decimal, 29, "%hu", &i );
 315     CHECK_EQUAL( i, 32767 );
 316     }
 317     {
 318     // reading +32767, u
 319     unsigned short i = -1;
 320     TESTSCAN( 1, 6, decimal, 28, "%hu", &i );
 321     CHECK_EQUAL( i, 32767 );
 322     }
 323     {
 324     // reading 65535, u
 325     unsigned short i = 0;
 326     TESTSCAN( 1, 5, decimal, 36, "%hu", &i );
 327     CHECK_EQUAL( i, 65535 );
 328     }
 329     {
 330     // reading +65535, u
 331     unsigned short i = 0;
 332     TESTSCAN( 1, 6, decimal, 35, "%hu", &i );
 333     CHECK_EQUAL( i, 65535 );
 334     }
 335     {
 336     // reading 0, i
 337     signed short i = -1;
 338     TESTSCAN( 1, 1, decimal, 1, "%hi", &i );
 339     CHECK_EQUAL( i, 0 );
 340     }
 341     {
 342     // reading -0, i
 343     signed short i = -1;
 344     TESTSCAN( 1, 2, decimal, 0, "%hi", &i );
 345     CHECK_EQUAL( i, 0 );
 346     }
 347     {
 348     // reading +0, i
 349     signed short i = -1;
 350     TESTSCAN( 1, 2, decimal, 3, "%hi", &i );
 351     CHECK_EQUAL( i, 0 );
 352     }
 353     {
 354     // reading -32768, i
 355     signed short i = -1;
 356     TESTSCAN( 1, 6, decimal, 21, "%hi", &i );
 357     CHECK_EQUAL( i, -32768 );
 358     }
 359     {
 360     // reading 32767, i
 361     signed short i = -1;
 362     TESTSCAN( 1, 5, decimal, 29, "%hi", &i );
 363     CHECK_EQUAL( i, 32767 );
 364     }
 365     {
 366     // reading +32767, i
 367     signed short i = -1;
 368     TESTSCAN( 1, 6, decimal, 28, "%hi", &i );
 369     CHECK_EQUAL( i, 32767 );
 370     }
 371     {
 372     // reading 0, d
 373     signed int i = -1;
 374     TESTSCAN( 1, 1, decimal, 1, "%d", &i );
 375     CHECK_EQUAL( i, 0 );
 376     }
 377     {
 378     // reading -0, d
 379     signed int i = -1;
 380     TESTSCAN( 1, 2, decimal, 0, "%d", &i );
 381     CHECK_EQUAL( i, 0 );
 382     }
 383     {
 384     // reading +0, d
 385     signed int i = -1;
 386     TESTSCAN( 1, 2, decimal, 3, "%d", &i );
 387     CHECK_EQUAL( i, 0 );
 388     }
 389     {
 390     // reading -2147483648, d
 391     signed int i = -1;
 392     TESTSCAN( 1, 11, decimal, 42, "%d", &i );
 393     CHECK_EQUAL( i, -2147483648 );
 394     }
 395     {
 396     // reading 2147483647, d
 397     signed int i = -1;
 398     TESTSCAN( 1, 10, decimal, 55, "%d", &i );
 399     CHECK_EQUAL( i, 2147483647 );
 400     }
 401     {
 402     // reading +2147483647, d
 403     signed int i = -1;
 404     TESTSCAN( 1, 11, decimal, 54, "%d", &i );
 405     CHECK_EQUAL( i, 2147483647 );
 406     }
 407     {
 408     // reading 0, u
 409     unsigned int i = -1;
 410     TESTSCAN( 1, 1, decimal, 1, "%u", &i );
 411     CHECK_EQUAL( i, 0 );
 412     }
 413     {
 414     // reading -0, u
 415     unsigned int i = -1;
 416     TESTSCAN( 1, 2, decimal, 0, "%u", &i );
 417     CHECK_EQUAL( i, 0 );
 418     }
 419     {
 420     // reading +0, u
 421     unsigned int i = -1;
 422     TESTSCAN( 1, 2, decimal, 3, "%u", &i );
 423     CHECK_EQUAL( i, 0 );
 424     }
 425     {
 426     // reading 2147483647, u
 427     unsigned int i = -1;
 428     TESTSCAN( 1, 10, decimal, 55, "%u", &i );
 429     CHECK_EQUAL( i, 2147483647 );
 430     }
 431     {
 432     // reading +2147483647, u
 433     unsigned int i = -1;
 434     TESTSCAN( 1, 11, decimal, 54, "%u", &i );
 435     CHECK_EQUAL( i, 2147483647 );
 436     }
 437     {
 438     // reading 4294967295, u
 439     unsigned int i = 0;
 440     TESTSCAN( 1, 10, decimal, 67, "%u", &i );
 441     CHECK_FEQUAL( i, 4294967295, unsigned int, "%u" );
 442     }
 443     {
 444     // reading +4294967295, u
 445     unsigned int i = 0;
 446     TESTSCAN( 1, 11, decimal, 66, "%u", &i );
 447     CHECK_FEQUAL( i, 4294967295, unsigned int, "%u" );
 448     }
 449     {
 450     // reading 0, i
 451     signed int i = -1;
 452     TESTSCAN( 1, 1, decimal, 1, "%i", &i );
 453     CHECK_EQUAL( i, 0 );
 454     }
 455     {
 456     // reading -0, i
 457     signed int i = -1;
 458     TESTSCAN( 1, 2, decimal, 0, "%i", &i );
 459     CHECK_EQUAL( i, 0 );
 460     }
 461     {
 462     // reading +0, i
 463     signed int i = -1;
 464     TESTSCAN( 1, 2, decimal, 3, "%i", &i );
 465     CHECK_EQUAL( i, 0 );
 466     }
 467     {
 468     // reading -2147483648, i
 469     signed int i = -1;
 470     TESTSCAN( 1, 11, decimal, 42, "%i", &i );
 471     CHECK_EQUAL( i, -2147483648 );
 472     }
 473     {
 474     // reading 2147483647, i
 475     signed int i = -1;
 476     TESTSCAN( 1, 10, decimal, 55, "%i", &i );
 477     CHECK_EQUAL( i, 2147483647 );
 478     }
 479     {
 480     // reading +2147483647, i
 481     signed int i = -1;
 482     TESTSCAN( 1, 11, decimal, 54, "%i", &i );
 483     CHECK_EQUAL( i, 2147483647 );
 484     }
 485     {
 486     // reading 0, d
 487     signed long i = -1;
 488     TESTSCAN( 1, 1, decimal, 1, "%ld", &i );
 489     CHECK_EQUAL( i, 0l );
 490     }
 491     {
 492     // reading -0, d
 493     signed long i = -1;
 494     TESTSCAN( 1, 2, decimal, 0, "%ld", &i );
 495     CHECK_EQUAL( i, 0l );
 496     }
 497     {
 498     // reading +0, d
 499     signed long i = -1;
 500     TESTSCAN( 1, 2, decimal, 3, "%ld", &i );
 501     CHECK_EQUAL( i, 0l );
 502     }
 503     {
 504     // reading -2147483648, d
 505     signed long i = -1;
 506     TESTSCAN( 1, 11, decimal, 42, "%ld", &i );
 507     CHECK_EQUAL( i, -2147483648l );
 508     }
 509     {
 510     // reading 2147483647, d
 511     signed long i = -1;
 512     TESTSCAN( 1, 10, decimal, 55, "%ld", &i );
 513     CHECK_EQUAL( i, 2147483647l );
 514     }
 515     {
 516     // reading +2147483647, d
 517     signed long i = -1;
 518     TESTSCAN( 1, 11, decimal, 54, "%ld", &i );
 519     CHECK_EQUAL( i, 2147483647l );
 520     }
 521     {
 522     // reading 0, u
 523     unsigned long i = -1;
 524     TESTSCAN( 1, 1, decimal, 1, "%lu", &i );
 525     CHECK_EQUAL( i, 0ul );
 526     }
 527     {
 528     // reading -0, u
 529     unsigned long i = -1;
 530     TESTSCAN( 1, 2, decimal, 0, "%lu", &i );
 531     CHECK_EQUAL( i, 0ul );
 532     }
 533     {
 534     // reading +0, u
 535     unsigned long i = -1;
 536     TESTSCAN( 1, 2, decimal, 3, "%lu", &i );
 537     CHECK_EQUAL( i, 0ul );
 538     }
 539     {
 540     // reading 2147483647, u
 541     unsigned long i = -1;
 542     TESTSCAN( 1, 10, decimal, 55, "%lu", &i );
 543     CHECK_EQUAL( i, 2147483647ul );
 544     }
 545     {
 546     // reading +2147483647, u
 547     unsigned long i = -1;
 548     TESTSCAN( 1, 11, decimal, 54, "%lu", &i );
 549     CHECK_EQUAL( i, 2147483647ul );
 550     }
 551     {
 552     // reading 4294967295, u
 553     unsigned long i = 0;
 554     TESTSCAN( 1, 10, decimal, 67, "%lu", &i );
 555     CHECK_FEQUAL( i, 4294967295ul, unsigned long, "%lu" );
 556     }
 557     {
 558     // reading +4294967295, u
 559     unsigned long i = 0;
 560     TESTSCAN( 1, 11, decimal, 66, "%lu", &i );
 561     CHECK_FEQUAL( i, 4294967295ul, unsigned long, "%lu" );
 562     }
 563     {
 564     // reading 0, i
 565     signed long i = -1;
 566     TESTSCAN( 1, 1, decimal, 1, "%li", &i );
 567     CHECK_EQUAL( i, 0l );
 568     }
 569     {
 570     // reading -0, i
 571     signed long i = -1;
 572     TESTSCAN( 1, 2, decimal, 0, "%li", &i );
 573     CHECK_EQUAL( i, 0l );
 574     }
 575     {
 576     // reading +0, i
 577     signed long i = -1;
 578     TESTSCAN( 1, 2, decimal, 3, "%li", &i );
 579     CHECK_EQUAL( i, 0l );
 580     }
 581     {
 582     // reading -2147483648, i
 583     signed long i = -1;
 584     TESTSCAN( 1, 11, decimal, 42, "%li", &i );
 585     CHECK_EQUAL( i, -2147483648l );
 586     }
 587     {
 588     // reading 2147483647, i
 589     signed long i = -1;
 590     TESTSCAN( 1, 10, decimal, 55, "%li", &i );
 591     CHECK_EQUAL( i, 2147483647l );
 592     }
 593     {
 594     // reading +2147483647, i
 595     signed long i = -1;
 596     TESTSCAN( 1, 11, decimal, 54, "%li", &i );
 597     CHECK_EQUAL( i, 2147483647l );
 598     }
 599     {
 600     // reading 0, d
 601     signed long long i = -1;
 602     TESTSCAN( 1, 1, decimal, 1, "%lld", &i );
 603     CHECK_EQUAL( i, 0ll );
 604     }
 605     {
 606     // reading -0, d
 607     signed long long i = -1;
 608     TESTSCAN( 1, 2, decimal, 0, "%lld", &i );
 609     CHECK_EQUAL( i, 0ll );
 610     }
 611     {
 612     // reading +0, d
 613     signed long long i = -1;
 614     TESTSCAN( 1, 2, decimal, 3, "%lld", &i );
 615     CHECK_EQUAL( i, 0ll );
 616     }
 617     {
 618     // reading -9223372036854775808, d
 619     signed long long i = -1;
 620     TESTSCAN( 1, 20, decimal, 78, "%lli", &i );
 621     CHECK_FEQUAL( i, LLONG_MIN, signed long long, "%lli" ); // should be literal -9223372036854775808ll but GCC balks.
 622     CHECK_EQUAL( i < 0ll, 1 );
 623     }
 624     {
 625     // reading +9223372036854775807, d
 626     signed long long i = -1;
 627     TESTSCAN( 1, 20, decimal, 99, "%lld", &i );
 628     CHECK_FEQUAL( i, 9223372036854775807ll, signed long long, "%lld" );
 629     }
 630     {
 631     // reading 0, u
 632     unsigned long long i = -1;
 633     TESTSCAN( 1, 1, decimal, 1, "%llu", &i );
 634     CHECK_EQUAL( i, 0ull );
 635     }
 636     {
 637     // reading -0, u
 638     unsigned long long i = -1;
 639     TESTSCAN( 1, 2, decimal, 0, "%llu", &i );
 640     CHECK_EQUAL( i, 0ull );
 641     }
 642     {
 643     // reading +0, u
 644     unsigned long long i = -1;
 645     TESTSCAN( 1, 2, decimal, 3, "%llu", &i );
 646     CHECK_EQUAL( i, 0ull );
 647     }
 648     {
 649     // reading 9223372036854775807, u
 650     unsigned long long i = -1;
 651     TESTSCAN( 1, 19, decimal, 100, "%llu", &i );
 652     CHECK_FEQUAL( i, 9223372036854775807ull, unsigned long long, "%llu" );
 653     }
 654     {
 655     // reading +9223372036854775807, u
 656     unsigned long long i = -1;
 657     TESTSCAN( 1, 20, decimal, 99, "%llu", &i );
 658     CHECK_FEQUAL( i, 9223372036854775807ull, unsigned long long, "%llu" );
 659     }
 660     {
 661     // reading 18446744073709551615, u
 662     unsigned long long i = 0;
 663     TESTSCAN( 1, 20, decimal, 121, "%llu", &i );
 664     CHECK_FEQUAL( i, 18446744073709551615ull, unsigned long long, "%llu" );
 665     }
 666     {
 667     // reading +18446744073709551615, u
 668     unsigned long long i = 0;
 669     TESTSCAN( 1, 21, decimal, 120, "%llu", &i );
 670     CHECK_FEQUAL( i, 18446744073709551615ull, unsigned long long, "%llu" );
 671     }
 672     {
 673     // reading 0, i
 674     signed long long i = -1;
 675     TESTSCAN( 1, 1, decimal, 1, "%lli", &i );
 676     CHECK_EQUAL( i, 0ll );
 677     }
 678     {
 679     // reading -0, i
 680     signed long long i = -1;
 681     TESTSCAN( 1, 2, decimal, 0, "%lli", &i );
 682     CHECK_EQUAL( i, 0ll );
 683     }
 684     {
 685     // reading +0, i
 686     signed long long i = -1;
 687     TESTSCAN( 1, 2, decimal, 3, "%lli", &i );
 688     CHECK_EQUAL( i, 0ll );
 689     }
 690     {
 691     // reading -9223372036854775808, i
 692     signed long long i = -1;
 693     TESTSCAN( 1, 20, decimal, 78, "%lli", &i );
 694     CHECK_FEQUAL( i, LLONG_MIN, signed long long, "%lli" ); // should be literal -9223372036854775808ll but GCC balks.
 695     CHECK_EQUAL( i < 0ll, 1 );
 696     }
 697     {
 698     // reading 9223372036854775807, i
 699     signed long long i = -1;
 700     TESTSCAN( 1, 19, decimal, 100, "%lli", &i );
 701     CHECK_FEQUAL( i, 9223372036854775807ll, signed long long, "%lli" );
 702     }
 703     {
 704     // reading +9223372036854775807, i
 705     signed long long i = -1;
 706     TESTSCAN( 1, 20, decimal, 99, "%lli", &i );
 707     CHECK_FEQUAL( i, 9223372036854775807ll, signed long long, "%lli" );
 708     }
 709
 710     // hexadecimal integer matches
 711     {
 712     // reading 0, x
 713     unsigned char i = -1;
 714     TESTSCAN( 1, 1, hexadecimal, 3, "%hhx", &i );
 715     CHECK_EQUAL( i, 0 );
 716     }
 717     {
 718     // reading -0x0, x
 719     unsigned char i = -1;
 720     TESTSCAN( 1, 4, hexadecimal, 0, "%hhx", &i );
 721     CHECK_EQUAL( i, 0 );
 722     }
 723     {
 724     // reading 0x000, x
 725     unsigned char i = -1;
 726     TESTSCAN( 1, 6, hexadecimal, 5, "%hhx", &i );
 727     CHECK_EQUAL( i, 0 );
 728     }
 729     {
 730     // reading 0x0, i
 731     signed char i = -1;
 732     TESTSCAN( 1, 4, hexadecimal, 0, "%hhi", &i );
 733     CHECK_EQUAL( i, 0 );
 734     }
 735     {
 736     // reading 7f, x
 737     unsigned char i = -1;
 738     TESTSCAN( 1, 2, hexadecimal, 15, "%hhx", &i );
 739     CHECK_EQUAL( i, 127 );
 740     }
 741     {
 742     // reading -0x7f, x
 743     unsigned char i = -1;
 744     TESTSCAN( 1, 5, hexadecimal, 12, "%hhx", &i );
 745     CHECK_FEQUAL( i, -127, unsigned char, "%hhu" );
 746     }
 747     {
 748     // reading 0x80, i
 749     signed char i = -1;
 750     TESTSCAN( 1, 4, hexadecimal, 18, "%hhi", &i );
 751     CHECK_FEQUAL( i, -128, signed char, "%hhd" );
 752     }
 753     {
 754     // reading ff, x
 755     unsigned char i = -1;
 756     TESTSCAN( 1, 2, hexadecimal, 25, "%hhx", &i );
 757     CHECK_EQUAL( i, 0xff );
 758     }
 759     {
 760     // reading 0xff, x
 761     unsigned char i = -1;
 762     TESTSCAN( 1, 4, hexadecimal, 23, "%hhx", &i );
 763     CHECK_EQUAL( i, 255 );
 764     }
 765     {
 766     // reading 0xff, i
 767     signed char i = 0;
 768     TESTSCAN( 1, 4, hexadecimal, 23, "%hhi", &i );
 769     CHECK_EQUAL( i, -1 );
 770     }
 771     {
 772     // reading 0, x
 773     unsigned short i = -1;
 774     TESTSCAN( 1, 1, hexadecimal, 3, "%hx", &i );
 775     CHECK_EQUAL( i, 0 );
 776     }
 777     {
 778     // reading -0x0, x
 779     unsigned short i = -1;
 780     TESTSCAN( 1, 4, hexadecimal, 0, "%hx", &i );
 781     CHECK_EQUAL( i, 0 );
 782     }
 783     {
 784     // reading 0x000, x
 785     unsigned short i = -1;
 786     TESTSCAN( 1, 6, hexadecimal, 5, "%hx", &i );
 787     CHECK_EQUAL( i, 0 );
 788     }
 789     {
 790     // reading 0x0, i
 791     signed short i = -1;
 792     TESTSCAN( 1, 4, hexadecimal, 0, "%hi", &i );
 793     CHECK_EQUAL( i, 0 );
 794     }
 795     {
 796     // reading 7fff, x
 797     unsigned short i = -1;
 798     TESTSCAN( 1, 4, hexadecimal, 31, "%hx", &i );
 799     CHECK_EQUAL( i, 32767 );
 800     }
 801     {
 802     // reading -0x7fff, x
 803     unsigned short i = -1;
 804     TESTSCAN( 1, 7, hexadecimal, 28, "%hx", &i );
 805     CHECK_FEQUAL( i, -32767, unsigned short, "%hu" );
 806     }
 807     {
 808     // reading 0x8000, i
 809     signed short i = -1;
 810     TESTSCAN( 1, 6, hexadecimal, 36, "%hi", &i );
 811     CHECK_FEQUAL( i, -32768, signed short, "%hd" );
 812     }
 813     {
 814     // reading ffff, x
 815     unsigned short i = -1;
 816     TESTSCAN( 1, 4, hexadecimal, 45, "%hx", &i );
 817     CHECK_EQUAL( i, 65535 );
 818     }
 819     {
 820     // reading 0xffff, x
 821     unsigned short i = -1;
 822     TESTSCAN( 1, 6, hexadecimal, 43, "%hx", &i );
 823     CHECK_EQUAL( i, 65535 );
 824     }
 825     {
 826     // reading 0xffff, i
 827     signed short i = 0;
 828     TESTSCAN( 1, 6, hexadecimal, 43, "%hi", &i );
 829     CHECK_FEQUAL( i, -1, signed short, "%hd" );
 830     }
 831     {
 832     // reading 0, x
 833     unsigned int i = -1;
 834     TESTSCAN( 1, 1, hexadecimal, 3, "%x", &i );
 835     CHECK_EQUAL( i, 0 );
 836     }
 837     {
 838     // reading -0x0, x
 839     unsigned int i = -1;
 840     TESTSCAN( 1, 4, hexadecimal, 0, "%x", &i );
 841     CHECK_EQUAL( i, 0 );
 842     }
 843     {
 844     // reading 0x000, x
 845     unsigned int i = -1;
 846     TESTSCAN( 1, 6, hexadecimal, 5, "%x", &i );
 847     CHECK_EQUAL( i, 0 );
 848     }
 849     {
 850     // reading 0x0, i
 851     signed int i = -1;
 852     TESTSCAN( 1, 4, hexadecimal, 0, "%i", &i );
 853     CHECK_EQUAL( i, 0 );
 854     }
 855     {
 856     // reading 7fffffff, x
 857     unsigned int i = -1;
 858     TESTSCAN( 1, 8, hexadecimal, 53, "%x", &i );
 859     CHECK_EQUAL( i, 2147483647 );
 860     }
 861     {
 862     // reading -0x7fffffff, x
 863     unsigned int i = -1;
 864     TESTSCAN( 1, 11, hexadecimal, 50, "%x", &i );
 865     CHECK_FEQUAL( i, -2147483647, unsigned int, "%u" );
 866     }
 867     {
 868     // reading 0x80000000, i
 869     signed int i = -1;
 870     //TESTSCAN( 1, 11, hexadecimal, 62, "%i", &i );
 871     CHECK_EQUAL( sscanf( "-0x80000000", "%i", &i );
 872     CHECK_FEQUAL( i, -2147483648, signed int, "%d" );
 873     }
 874     {
 875     // reading ffffffff, x
 876     unsigned int i = -1;
 877     TESTSCAN( 1, 8, hexadecimal, 75, "%x", &i );
 878     CHECK_FEQUAL( i, 4294967295, unsigned int, "%d" );
 879     }
 880     {
 881     // reading 0xffffffff, x
 882     unsigned int i = -1;
 883     TESTSCAN( 1, 10, hexadecimal, 73, "%x", &i );
 884     CHECK_FEQUAL( i, 4294967295, unsigned int, "%d" );
 885     }
 886
 887     // octal integer matches
 888     {
 889     // reading 0, o
 890     unsigned char i = -1;
 891     TESTSCAN( 1, 1, octal, 4, "%hho", &i );
 892     CHECK_EQUAL( i, 0u );
 893     }
 894     {
 895     // reading +0000, o
 896     unsigned char i = -1;
 897     TESTSCAN( 1, 5, octal, 0, "%hho", &i );
 898     CHECK_EQUAL( i, 0u );
 899     }
 900     {
 901     // reading -0000, o
 902     unsigned char i = -1;
 903     TESTSCAN( 1, 5, octal, 6, "%hho", &i );
 904     CHECK_EQUAL( i, 0u );
 905     }
 906     {
 907     // reading 0177, o
 908     unsigned char i = -1;
 909     TESTSCAN( 1, 4, octal, 13, "%hho", &i );
 910     CHECK_EQUAL( i, 127u );
 911     }
 912     {
 913     // reading +0177, o
 914     unsigned char i = -1;
 915     TESTSCAN( 1, 5, octal, 12, "%hho", &i );
 916     CHECK_EQUAL( i, 127u );
 917     }
 918     {
 919     // reading 0377, o
 920     unsigned char i = -1;
 921     TESTSCAN( 1, 4, octal, 19, "%hho", &i );
 922     CHECK_FEQUAL( i, 255u, unsigned char, "%hhu" );
 923     }
 924     {
 925     // reading +0377, o
 926     unsigned char i = -1;
 927     TESTSCAN( 1, 5, octal, 18, "%hho", &i );
 928     CHECK_FEQUAL( i, 255u, unsigned char, "%hhu" );
 929     }
 930     {
 931     // reading -0377, o
 932     unsigned char i = -1;
 933     TESTSCAN( 1, 5, octal, 24, "%hho", &i );
 934     CHECK_FEQUAL( i, 1u, unsigned char, "%hhu" );
 935     }
 936     {
 937     // reading 077777, o
 938     unsigned short i = -1;
 939     TESTSCAN( 1, 6, octal, 31, "%ho", &i );
 940     CHECK_EQUAL( i, 32767u );
 941     }
 942     {
 943     // reading +077777, o
 944     unsigned short i = -1;
 945     TESTSCAN( 1, 7, octal, 30, "%ho", &i );
 946     CHECK_EQUAL( i, 32767u );
 947     }
 948     {
 949     // reading 0177777, o
 950     unsigned short i = -1;
 951     TESTSCAN( 1, 7, octal, 39, "%ho", &i );
 952     CHECK_FEQUAL( i, 65535u, unsigned short, "%hu" );
 953     }
 954     {
 955     // reading +0177777, o
 956     unsigned short i = -1;
 957     TESTSCAN( 1, 8, octal, 38, "%ho", &i );
 958     CHECK_FEQUAL( i, 65535u, unsigned short, "%hu" );
 959     }
 960     {
 961     // reading -0177777, o
 962     unsigned short i = -1;
 963     TESTSCAN( 1, 8, octal, 47, "%ho", &i );
 964     CHECK_FEQUAL( i, 1u, unsigned short, "%hu" );
 965     }
 966     {
 967     // reading 017777777777, o
 968     unsigned int i = -1;
 969     TESTSCAN( 1, 12, octal, 57, "%o", &i );
 970     CHECK_EQUAL( i, 2147483647u );
 971     }
 972     {
 973     // reading +017777777777, o
 974     unsigned int i = -1;
 975     TESTSCAN( 1, 13, octal, 56, "%o", &i );
 976     CHECK_EQUAL( i, 2147483647u );
 977     }
 978     {
 979     // reading 037777777777, o
 980     unsigned int i = -1;
 981     TESTSCAN( 1, 12, octal, 71, "%o", &i );
 982     CHECK_FEQUAL( i, 4294967295u, unsigned int, "%u" );
 983     }
 984     {
 985     // reading +037777777777, o
 986     unsigned int i = -1;
 987     TESTSCAN( 1, 13, octal, 70, "%o", &i );
 988     CHECK_FEQUAL( i, 4294967295u, unsigned int, "%u" );
 989     }
 990     {
 991     // reading -037777777777, o
 992     unsigned int i = -1;
 993     TESTSCAN( 1, 13, octal, 84, "%o", &i );
 994     CHECK_FEQUAL( i, 1u, unsigned int, "%u" );
 995     }
 996     {
 997     // reading 017777777777, o
 998     unsigned long i = -1;
 999     TESTSCAN( 1, 12, octal, 57, "%lo", &i );
1000     CHECK_EQUAL( i, 2147483647lu );
1001     }
1002     {
1003     // reading +017777777777, o
1004     unsigned long i = -1;
1005     TESTSCAN( 1, 13, octal, 56, "%lo", &i );
1006     CHECK_EQUAL( i, 2147483647lu );
1007     }
1008     {
1009     // reading 037777777777, o
1010     unsigned long i = -1;
1011     TESTSCAN( 1, 12, octal, 71, "%lo", &i );
1012     CHECK_FEQUAL( i, 4294967295lu, unsigned long, "%lu" );
1013     }
1014     {
1015     // reading +037777777777, o
1016     unsigned long i = -1;
1017     TESTSCAN( 1, 13, octal, 70, "%lo", &i );
1018     CHECK_FEQUAL( i, 4294967295lu, unsigned long, "%lu" );
1019     }
1020     {
1021     // reading -037777777777, o
1022     unsigned long i = -1;
1023     TESTSCAN( 1, 13, octal, 84, "%lo", &i );
1024     CHECK_FEQUAL( i, 1lu, unsigned long, "%lu" );
1025     }
1026     {
1027     // reading 0777777777777777777777, o
1028     unsigned long long i = -1;
1029     TESTSCAN( 1, 22, octal, 99, "%llo", &i );
1030     CHECK_FEQUAL( i, 9223372036854775807llu, unsigned long long, "%llu" );
1031     }
1032     {
1033     // reading +0777777777777777777777, o
1034     unsigned long long i = -1;
1035     TESTSCAN( 1, 23, octal, 98, "%llo", &i );
1036     CHECK_FEQUAL( i, 9223372036854775807llu, unsigned long long, "%llu" );
1037     }
1038     {
1039     // reading 01777777777777777777777, o
1040     unsigned long long i = -1;
1041     TESTSCAN( 1, 23, octal, 123, "%llo", &i );
1042     CHECK_FEQUAL( i, 18446744073709551615llu, unsigned long long, "%llu" );
1043     }
1044     {
1045     // reading +01777777777777777777777, o
1046     unsigned long long i = -1;
1047     TESTSCAN( 1, 24, octal, 122, "%llo", &i );
1048     CHECK_FEQUAL( i, 18446744073709551615llu, unsigned long long, "%llu" );
1049     }
1050     {
1051     // reading -01777777777777777777777, o
1052     unsigned long long i = -1;
1053     TESTSCAN( 1, 24, octal, 147, "%llo", &i );
1054     CHECK_FEQUAL( i, 1llu, unsigned long long, "%llu" );
1055     }
1056
1057     // string matches
1058     size_t const BUFSIZE = 1000;
1059     char buffer[BUFSIZE];
1060     {
1061     // reading abc
1062     memset( buffer, '\0', BUFSIZE );
1063     TESTSCAN( 1, 3, alpha, 0, "%[abc]", buffer );
1064     CHECK_FALSE( memcmp( buffer, "abc", 4 ) );
1065     }
1066     {
1067     // reading a-c
1068     memset( buffer, '\0', BUFSIZE );
1069     TESTSCAN( 1, 3, alpha, 0, "%[a-c]", buffer );
1070     CHECK_FALSE( memcmp( buffer, "abc", 4 ) );
1071     }
1072     {
1073     // reading a-h
1074     memset( buffer, '\0', BUFSIZE );
1075     TESTSCAN( 1, 8, alpha, 0, "%[a-h]", buffer );
1076     CHECK_FALSE( memcmp( buffer, "abcdefgh", 9 ) );
1077     }
1078     {
1079     // reading o-r, including [, seperate char
1080     memset( buffer, '\0', BUFSIZE );
1081     TESTSCAN( 1, 5, alpha, 15, "%[[o-qr]", buffer );
1082     CHECK_FALSE( memcmp( buffer, "op[qr", 6 ) );
1083     }
1084     {
1085     // reading v-y, including ], two groups
1086     memset( buffer, '\0', BUFSIZE );
1087     TESTSCAN( 1, 5, alpha, 23, "%[]v-wx-y]", buffer );
1088     CHECK_FALSE( memcmp( buffer, "vw]xy", 6 ) );
1089     }
1090     {
1091     // missing on first character
1092     memset( buffer, '\0', BUFSIZE );
1093     TESTSCAN( 0, -1, alpha, 0, "%[b]", buffer );
1094     CHECK_FALSE( memcmp( buffer, "", 1 ) );
1095     }
1096     {
1097     // eof while reading, two groups
1098     memset( buffer, '\0', BUFSIZE );
1099     TESTSCAN( 1, 2, alpha, 27, "%[a-zA-Z]", buffer );
1100     CHECK_FALSE( memcmp( buffer, "yz", 3 ) );
1101     }
1102     {
1103     // eof before reading
1104     memset( buffer, '\0', BUFSIZE );
1105     TESTSCAN( -1, -1, alpha, 29, "%[a-z]", buffer ) );
1106     CHECK_FALSE( memcmp( buffer, "", 1 ) );
1107     }
1108     {
1109     // negation - [^...]
1110     memset( buffer, '\0', BUFSIZE );
1111     TESTSCAN( 1, 3, alpha, 0, "%[^d-f]", buffer );
1112     CHECK_FALSE( memcmp( buffer, "abc", 4 ) );
1113     }
1114
1115     // special bordercase
1116     {
1117     // reading -0x, x
1118     unsigned char i = 1;
1119     /* Most existing libraries disagree with this test case, so a little
1120        explanation of why PDCLib chose the implementation it did might be
1121        necessary. All references are from ISO/IEC 9899:1999 "Programming
1122        languages - C". Wording critical to the explanation is in UPPERCASE.
1123        Input stream holds "-0xz".
1124        6.4.4.1 Integer constants - states that '0' is a valid (hexa)decimal
1125            constant, whereas '0x' IS NOT.
1126        7.19.6.2 The fscanf function - states...
1127            ...in paragraph 9 that "an INPUT ITEM is defined as the longest
1128                sequence of input characters [...] which is, OR IS A PREFIX OF,
1129                a matching input sequence".
1130            ...in paragraph 10 that "if the INPUT ITEM is not a matching
1131                sequence, the execution of THE DIRECTIVE FAILS; this condition
1132                is a matching failure".
1133            ...in footnote 242) that "fscanf pushes back AT MOST ONE input
1134                character onto the input stream."
1135            ...in paragraph 12 that either of the conversion specifiers d, i,
1136               o, u, or x "matches an [...] integer whose format is the same as
1137               expected for THE SUBJECT SEQUENCE of the [strtol|strtoul]
1138               function".
1139        7.20.1.4 The strtol, strtoll, strtoul, and strtoull functions - states
1140            in paragraph 3 that "the EXPECTED FORM OF THE SUBJECT SEQUENCE is
1141            that of an integer constant AS DESCRIBED IN 6.4.4.1".
1142        These parts of the standard result in the following reasoning:
1143        - The longest sequence of input characters which is a prefix of a
1144          matching input sequence is "-0x" (negative sign, hexadecimal-prefix).
1145          The 'z' is the first character remaining unread as "-0xz" is not a
1146          (prefix of a) matching input sequence. This is according to 7.19.6.2
1147          paragraph 9.
1148        - "0x", without a valid hexadecimal digit following it, is not a valid
1149          integer constant according to 6.4.4.1.
1150        - "0x" is thus also not of the expected form for a strto[u]l subject
1151          sequence according to 7.20.1.4 paragraph 3. (strto[u]l() would parse
1152          it as zero, but leave the "x" in the final string, i.e. outside the
1153          subject sequence.)
1154        - "0x" is therefore also not a matching sequence to the i or x
1155          conversion specifier according to 7.19.6.2 paragraph 12.
1156        - The conversion should therefore result in a matching failure
1157          according to 7.19.6.2 paragraph 10.
1158     */
1159     TESTSCAN( 0, -1, special, 0, "%hhx", &i );
1160     CHECK_EQUAL( i, 1 );
1161     }
1162     {
1163     // reading -0x, x
1164     unsigned short i = 1;
1165     TESTSCAN( 0, -1, special, 0, "%hx", &i );
1166     CHECK_EQUAL( i, 1 );
1167     }
1168     {
1169     // reading -0x, x
1170     unsigned int i = 1;
1171     TESTSCAN( 0, -1, special, 0, "%x", &i );
1172     CHECK_EQUAL( i, 1 );
1173     }