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