pd.if.org Git - pdclib/blob - functions/stdio/sscanf.c

   1 /* $Id$ */
   2
   3 /* sscanf( const char *, const char *, ... )
   4
   5    This file is part of the Public Domain C Library (PDCLib).
   6    Permission is granted to use, modify, and / or redistribute at will.
   7 */
   8
   9 #include <stdio.h>
  10 #include <stdarg.h>
  11
  12 #ifndef REGTEST
  13
  14 int sscanf( const char * _PDCLIB_restrict s, const char * _PDCLIB_restrict format, ... )
  15 {
  16     int rc;
  17     va_list ap;
  18     va_start( ap, format );
  19     rc = vsscanf( s, format, ap );
  20     va_end( ap );
  21     return rc;
  22 }
  23
  24 #endif
  25
  26 #ifdef TEST
  27 #include <_PDCLIB_test.h>
  28
  29 #include <string.h>
  30 #include <limits.h>
  31
  32 #define symbol2value( x ) #x
  33 #define symbol2string( x ) symbol2value( x )
  34
  35 #define CHECK_TRUE( a ) do { if ( a == 0 ) { fprintf( stderr, "Unexpected failure in " symbol2string( __LINE__ ) ": '" #a "' evaluated to false.\n" ); rc += 1; } } while ( 0 )
  36 #define CHECK_FALSE( a ) do { if ( a != 0 ) { fprintf( stderr, "Unexpected failure in " symbol2string( __LINE__ ) ": '" #a "' evaluated to true.\n" ); rc += 1; } } while ( 0 )
  37 #define CHECK_EQUAL( a, b ) do { int x = a; int y = b; if ( x != y ) { fprintf( stderr, "Mismatch in " symbol2string( __LINE__ ) ": result is %d, expected %d.\n", x, y ); rc += 1; } } while ( 0 )
  38 #define CHECK_FEQUAL( a, b, T, F ) do { T x = a; T y = b; if ( x != y ) { fprintf( stderr, "Mismatch in " symbol2string( __LINE__ ) ": result is " F ", expected " F ".\n", x, y ); rc += 1; } } while ( 0 )
  39
  40 // literal matches, character matches, and basic integer matches
  41 void suite_one( void );
  42 // decimal integer matches
  43 void suite_two( void );
  44 // hexadecimal integer matches
  45 void suite_three( void );
  46 // octal integer matches
  47 void suite_four( void );
  48 // string matches
  49 void suite_five( void );
  50
  51 int main()
  52 {
  53     suite_one();
  54     suite_two();
  55     suite_three();
  56     suite_four();
  57     suite_five();
  58 }
  59
  60 // literal matches, character matches, and basic integer matches
  61 void suite_one()
  62 {
  63     char const * string = "12345678901\0003-5+7\0009\3772 4 6 8 0\3771 \011 5%%  0";
  64     CHECK_EQUAL( string[39], '0' );
  65
  66     // -----------------------------------------------------------------------
  67     // Literal matching
  68     // -----------------------------------------------------------------------
  69     {
  70     // matching six characters literally
  71     // checking via %n
  72     // should report six characters read
  73     int n;
  74     CHECK_EQUAL( sscanf( string + 0, "123456%n", &n ), 0 );
  75     CHECK_EQUAL( n, 6 );
  76     }
  77     {
  78     // matching a character, three whitespace chars, and another character
  79     // checking via %n
  80     // should report five characters read
  81     int n;
  82     CHECK_EQUAL( sscanf( string + 30, "1 5%n", &n ), 0 );
  83     CHECK_EQUAL( n, 5 );
  84     }
  85     {
  86     // matching three characters, not matching whitespaces, and matching another three characters
  87     // checking via %n
  88     // should report six characters matched
  89     int n;
  90     CHECK_EQUAL( sscanf( string + 0, "123  456%n", &n ), 0 );
  91     CHECK_EQUAL( n, 6 );
  92     }
  93     {
  94     // matching a character, two '%' characters, and two whitespaces
  95     // checking via %n
  96     // should report five characters matched
  97     int n;
  98     CHECK_EQUAL( sscanf( string + 34, "5%%%% %n", &n ), 0 );
  99     CHECK_EQUAL( n, 5 );
 100     }
 101     {
 102     // seeking to last character in file, trying to match that char and a whitespace
 103     // checking via %n
 104     // should report one character matched and EOF
 105     int n;
 106     CHECK_EQUAL( sscanf( string + 39, "0 %n", &n ), 0 );
 107     CHECK_EQUAL( n, 1 );
 108     }
 109     {
 110     // seeking to end of file, trying to match a -1
 111     // checking via %n
 112     // should report error, not executing %n
 113     int n = -1;
 114     CHECK_EQUAL( sscanf( string + 0, "\377%n", &n ), 0 );
 115     CHECK_EQUAL( n, -1 );
 116     }
 117
 118     // -----------------------------------------------------------------------
 119     // Character matching ('%c')
 120     // -----------------------------------------------------------------------
 121     {
 122     // reading a char array of specified width, including zero bytes
 123     // should report the characters read up to first zero
 124     char buffer[ 8 ];
 125     memset( buffer, '\177', 8 );
 126     CHECK_EQUAL( sscanf( string + 10, "%7c", buffer ), 1 );
 127     CHECK_FALSE( memcmp( buffer, "1\177\177", 3 ) );
 128     }
 129     {
 130     // reading a char array of unspecified width when positioned at -1 value
 131     // should default to width one, read the -1 value, no zero termination of the array
 132     char buffer[ 2 ];
 133     memset( buffer, '\177', 2 );
 134     CHECK_EQUAL( sscanf( string + 19, "%c", buffer ), 1 );
 135     CHECK_FALSE( memcmp( buffer, "\377\177", 2 ) );
 136     }
 137     {
 138     // reading a char array of specified width 1 when positioned at (non-space) whitespace
 139     // should read the whitespace (literally), no zero termination of the array
 140     char buffer[ 2 ];
 141     memset( buffer, '\177', 2 );
 142     CHECK_EQUAL( sscanf( string + 32, "%1c", buffer ), 1 );
 143     CHECK_FALSE( memcmp( buffer, "\011\177", 2 ) );
 144     }
 145     {
 146     // reading a char array of specified width 2 when positioned at last char of file
 147     // should read the character, and report EOF
 148     char buffer[ 2 ];
 149     memset( buffer, '\177', 2 );
 150     CHECK_EQUAL( sscanf( string + 39, "%2c", buffer ), 1 );
 151     CHECK_FALSE( memcmp( buffer, "0\177", 2 ) );
 152     }
 153     {
 154     // reading a char array of specified width 1 when positioned at last char of file
 155     // should read the character, and NOT report EOF
 156     char buffer[ 2 ];
 157     memset( buffer, '\177', 2 );
 158     CHECK_EQUAL( sscanf( string + 39, "%1c", buffer ), 1 );
 159     CHECK_FALSE( memcmp( buffer, "0\177", 2 ) );
 160     }
 161     {
 162     // reading a char array of specified width 1 when positioned at EOF
 163     // should report input error before any conversion (-1)
 164     char buffer[ 2 ];
 165     memset( buffer, '\177', 2 );
 166     CHECK_EQUAL( sscanf( string + 40, "%1c", buffer ), -1 );
 167     CHECK_FALSE( memcmp( buffer, "\177\177", 2 ) );
 168     }
 169
 170     // -----------------------------------------------------------------------
 171     // Integer matching ('%d')
 172     // -----------------------------------------------------------------------
 173     {
 174     // reading a whitespace-terminated integer
 175     int i;
 176     int n;
 177     CHECK_EQUAL( sscanf( string + 20, "%d%n", &i, &n ), 1 );
 178     CHECK_EQUAL( i, 2 );
 179     CHECK_EQUAL( n, 1 );
 180     }
 181     {
 182     // reading a -1 terminated integer
 183     int i;
 184     int n;
 185     CHECK_EQUAL( sscanf( string + 18, "%d%n", &i, &n ), 1 );
 186     CHECK_EQUAL( i, 9 );
 187     CHECK_EQUAL( n, 1 );
 188     }
 189     {
 190     // reading a EOF terminated integer
 191     int i = -1;
 192     int n;
 193     CHECK_EQUAL( sscanf( string + 39, "%d%n", &i, &n ), 1 );
 194     CHECK_EQUAL( i, 0 );
 195     CHECK_EQUAL( n, 1 );
 196     }
 197     {
 198     // trying to read an integer when positioned at whitespace
 199     // should skip whitespaces
 200     int i = -1;
 201     int n;
 202     CHECK_EQUAL( sscanf( string + 32, "%d%n", &i, &n ), 1 );
 203     CHECK_EQUAL( i, 5 );
 204     CHECK_EQUAL( n, 3 );
 205     }
 206     {
 207     // trying to read an integer when positioned at -1 value
 208     // should report matching failure
 209     int i = 0;
 210     int n = -1;
 211     CHECK_EQUAL( sscanf( string + 19, "%d%n", &i, &n ), 0 );
 212     CHECK_EQUAL( i, 0 );
 213     CHECK_EQUAL( n, -1 );
 214     }
 215     {
 216     // trying to read an integer when positioned at EOF
 217     // should report reading failure
 218     int i = 0;
 219     int n = -1;
 220     CHECK_EQUAL( sscanf( string + 40, "%d%n", &i, &n ), -1 );
 221     CHECK_EQUAL( i, 0 );
 222     CHECK_EQUAL( n, -1 );
 223     }
 224     {
 225     // reading a '-'-prefixed integer
 226     int i;
 227     int n;
 228     CHECK_EQUAL( sscanf( string + 13, "%d%n", &i, &n ), 1 );
 229     CHECK_EQUAL( i, -5 );
 230     CHECK_EQUAL( n, 2 );
 231     }
 232     {
 233     // reading a '+'-prefixed integer
 234     int i;
 235     int n;
 236     CHECK_EQUAL( sscanf( string + 15, "%d%n", &i, &n ), 1 );
 237     CHECK_EQUAL( i, 7 );
 238     CHECK_EQUAL( n, 2 );
 239     }
 240 }
 241
 242 // decimal integer matches
 243 void suite_two()
 244 {
 245     char const * string = "-0 +0 -128 +127 +255 -32768 +32767 +65535\n"
 246                           "-2147483648 +2147483647 +4294967295\n"
 247                           "-9223372036854775808 +9223372036854775807\n"
 248                           "+18446744073709551615\n";
 249     CHECK_EQUAL( string[141], '\n' );
 250     {
 251     // reading 0, d
 252     signed char i = -1;
 253     int n;
 254     CHECK_EQUAL( sscanf( string + 1, "%hhd%n", &i, &n ), 1 );
 255     CHECK_EQUAL( i, 0 );
 256     CHECK_EQUAL( n, 1 );
 257     }
 258     {
 259     // reading -0, d
 260     signed char i = -1;
 261     int n;
 262     CHECK_EQUAL( sscanf( string + 0, "%hhd%n", &i, &n ), 1 );
 263     CHECK_EQUAL( i, 0 );
 264     CHECK_EQUAL( n, 2 );
 265     }
 266     {
 267     // reading +0, d
 268     signed char i = -1;
 269     int n;
 270     CHECK_EQUAL( sscanf( string + 3, "%hhd%n", &i, &n ), 1 );
 271     CHECK_EQUAL( i, 0 );
 272     CHECK_EQUAL( n, 2 );
 273     }
 274     {
 275     // reading -128, d
 276     signed char i = -1;
 277     int n;
 278     CHECK_EQUAL( sscanf( string + 6, "%hhd%n", &i, &n ), 1 );
 279     CHECK_EQUAL( i, -128 );
 280     CHECK_EQUAL( n, 4 );
 281     }
 282     {
 283     // reading 127, d
 284     signed char i = -1;
 285     int n;
 286     CHECK_EQUAL( sscanf( string + 12, "%hhd%n", &i, &n ), 1 );
 287     CHECK_EQUAL( i, 127 );
 288     CHECK_EQUAL( n, 3 );
 289     }
 290     {
 291     // reading +127, d
 292     signed char i = -1;
 293     int n;
 294     CHECK_EQUAL( sscanf( string + 11, "%hhd%n", &i, &n ), 1 );
 295     CHECK_EQUAL( i, 127 );
 296     CHECK_EQUAL( n, 4 );
 297     }
 298     {
 299     // reading 0, u
 300     unsigned char i = -1;
 301     int n;
 302     CHECK_EQUAL( sscanf( string + 1, "%hhu%n", &i, &n ), 1 );
 303     CHECK_EQUAL( i, 0 );
 304     CHECK_EQUAL( n, 1 );
 305     }
 306     {
 307     // reading -0, u
 308     unsigned char i = -1;
 309     int n;
 310     CHECK_EQUAL( sscanf( string + 0, "%hhu%n", &i, &n ), 1 );
 311     CHECK_EQUAL( i, 0 );
 312     CHECK_EQUAL( n, 2 );
 313     }
 314     {
 315     // reading +0, u
 316     unsigned char i = -1;
 317     int n;
 318     CHECK_EQUAL( sscanf( string + 3, "%hhu%n", &i, &n ), 1 );
 319     CHECK_EQUAL( i, 0 );
 320     CHECK_EQUAL( n, 2 );
 321     }
 322     {
 323     // reading 127, u
 324     unsigned char i = -1;
 325     int n;
 326     CHECK_EQUAL( sscanf( string + 12, "%hhu%n", &i, &n ), 1 );
 327     CHECK_EQUAL( i, 127 );
 328     CHECK_EQUAL( n, 3 );
 329     }
 330     {
 331     // reading +127, u
 332     unsigned char i = -1;
 333     int n;
 334     CHECK_EQUAL( sscanf( string + 11, "%hhu%n", &i, &n ), 1 );
 335     CHECK_EQUAL( i, 127 );
 336     CHECK_EQUAL( n, 4 );
 337     }
 338     {
 339     // reading 255, u
 340     unsigned char i = 0;
 341     int n;
 342     CHECK_EQUAL( sscanf( string + 17, "%hhu%n", &i, &n ), 1 );
 343     CHECK_EQUAL( i, 255 );
 344     CHECK_EQUAL( n, 3 );
 345     }
 346     {
 347     // reading +255, u
 348     unsigned char i = 0;
 349     int n;
 350     CHECK_EQUAL( sscanf( string + 16, "%hhu%n", &i, &n ), 1 );
 351     CHECK_EQUAL( i, 255 );
 352     CHECK_EQUAL( n, 4 );
 353     }
 354     {
 355     // reading 0, i
 356     signed char i = -1;
 357     int n;
 358     CHECK_EQUAL( sscanf( string + 1, "%hhi%n", &i, &n ), 1 );
 359     CHECK_EQUAL( i, 0 );
 360     CHECK_EQUAL( n, 1 );
 361     }
 362     {
 363     // reading -0, i
 364     signed char i = -1;
 365     int n;
 366     CHECK_EQUAL( sscanf( string + 0, "%hhi%n", &i, &n ), 1 );
 367     CHECK_EQUAL( i, 0 );
 368     CHECK_EQUAL( n, 2 );
 369     }
 370     {
 371     // reading +0, i
 372     signed char i = -1;
 373     int n;
 374     CHECK_EQUAL( sscanf( string + 3, "%hhi%n", &i, &n ), 1 );
 375     CHECK_EQUAL( i, 0 );
 376     CHECK_EQUAL( n, 2 );
 377     }
 378     {
 379     // reading -128, i
 380     signed char i = -1;
 381     int n;
 382     CHECK_EQUAL( sscanf( string + 6, "%hhi%n", &i, &n ), 1 );
 383     CHECK_EQUAL( i, -128 );
 384     CHECK_EQUAL( n, 4 );
 385     }
 386     {
 387     // reading 127, i
 388     signed char i = -1;
 389     int n;
 390     CHECK_EQUAL( sscanf( string + 12, "%hhi%n", &i, &n ), 1 );
 391     CHECK_EQUAL( i, 127 );
 392     CHECK_EQUAL( n, 3 );
 393     }
 394     {
 395     // reading +127, i
 396     signed char i = -1;
 397     int n;
 398     CHECK_EQUAL( sscanf( string + 11, "%hhi%n", &i, &n ), 1 );
 399     CHECK_EQUAL( i, 127 );
 400     CHECK_EQUAL( n, 4 );
 401     }
 402     {
 403     // reading 0, d
 404     signed short i = -1;
 405     int n;
 406     CHECK_EQUAL( sscanf( string + 1, "%hd%n", &i, &n ), 1 );
 407     CHECK_EQUAL( i, 0 );
 408     CHECK_EQUAL( n, 1 );
 409     }
 410     {
 411     // reading -0, d
 412     signed short i = -1;
 413     int n;
 414     CHECK_EQUAL( sscanf( string + 0, "%hd%n", &i, &n ), 1 );
 415     CHECK_EQUAL( i, 0 );
 416     CHECK_EQUAL( n, 2 );
 417     }
 418     {
 419     // reading +0, d
 420     signed short i = -1;
 421     int n;
 422     CHECK_EQUAL( sscanf( string + 3, "%hd%n", &i, &n ), 1 );
 423     CHECK_EQUAL( i, 0 );
 424     CHECK_EQUAL( n, 2 );
 425     }
 426     {
 427     // reading -32768, d
 428     signed short i = -1;
 429     int n;
 430     CHECK_EQUAL( sscanf( string + 21, "%hd%n", &i, &n ), 1 );
 431     CHECK_EQUAL( i, -32768 );
 432     CHECK_EQUAL( n, 6 );
 433     }
 434     {
 435     // reading 32767, d
 436     signed short i = -1;
 437     int n;
 438     CHECK_EQUAL( sscanf( string + 29, "%hd%n", &i, &n ), 1 );
 439     CHECK_EQUAL( i, 32767 );
 440     CHECK_EQUAL( n, 5 );
 441     }
 442     {
 443     // reading +32767, d
 444     signed short i = -1;
 445     int n;
 446     CHECK_EQUAL( sscanf( string + 28, "%hd%n", &i, &n ), 1 );
 447     CHECK_EQUAL( i, 32767 );
 448     CHECK_EQUAL( n, 6 );
 449     }
 450     {
 451     // reading 0, u
 452     unsigned short i = -1;
 453     int n;
 454     CHECK_EQUAL( sscanf( string + 1, "%hu%n", &i, &n ), 1 );
 455     CHECK_EQUAL( i, 0 );
 456     CHECK_EQUAL( n, 1 );
 457     }
 458     {
 459     // reading -0, u
 460     unsigned short i = -1;
 461     int n;
 462     CHECK_EQUAL( sscanf( string + 0, "%hu%n", &i, &n ), 1 );
 463     CHECK_EQUAL( i, 0 );
 464     CHECK_EQUAL( n, 2 );
 465     }
 466     {
 467     // reading +0, u
 468     unsigned short i = -1;
 469     int n;
 470     CHECK_EQUAL( sscanf( string + 3, "%hu%n", &i, &n ), 1 );
 471     CHECK_EQUAL( i, 0 );
 472     CHECK_EQUAL( n, 2 );
 473     }
 474     {
 475     // reading 32767, u
 476     unsigned short i = -1;
 477     int n;
 478     CHECK_EQUAL( sscanf( string + 29, "%hu%n", &i, &n ), 1 );
 479     CHECK_EQUAL( i, 32767 );
 480     CHECK_EQUAL( n, 5 );
 481     }
 482     {
 483     // reading +32767, u
 484     unsigned short i = -1;
 485     int n;
 486     CHECK_EQUAL( sscanf( string + 28, "%hu%n", &i, &n ), 1 );
 487     CHECK_EQUAL( i, 32767 );
 488     CHECK_EQUAL( n, 6 );
 489     }
 490     {
 491     // reading 65535, u
 492     unsigned short i = 0;
 493     int n;
 494     CHECK_EQUAL( sscanf( string + 36, "%hu%n", &i, &n ), 1 );
 495     CHECK_EQUAL( i, 65535 );
 496     CHECK_EQUAL( n, 5 );
 497     }
 498     {
 499     // reading +65535, u
 500     unsigned short i = 0;
 501     int n;
 502     CHECK_EQUAL( sscanf( string + 35, "%hu%n", &i, &n ), 1 );
 503     CHECK_EQUAL( i, 65535 );
 504     CHECK_EQUAL( n, 6 );
 505     }
 506     {
 507     // reading 0, i
 508     signed short i = -1;
 509     int n;
 510     CHECK_EQUAL( sscanf( string + 1, "%hi%n", &i, &n ), 1 );
 511     CHECK_EQUAL( i, 0 );
 512     CHECK_EQUAL( n, 1 );
 513     }
 514     {
 515     // reading -0, i
 516     signed short i = -1;
 517     int n;
 518     CHECK_EQUAL( sscanf( string + 0, "%hi%n", &i, &n ), 1 );
 519     CHECK_EQUAL( i, 0 );
 520     CHECK_EQUAL( n, 2 );
 521     }
 522     {
 523     // reading +0, i
 524     signed short i = -1;
 525     int n;
 526     CHECK_EQUAL( sscanf( string + 3, "%hi%n", &i, &n ), 1 );
 527     CHECK_EQUAL( i, 0 );
 528     CHECK_EQUAL( n, 2 );
 529     }
 530     {
 531     // reading -32768, i
 532     signed short i = -1;
 533     int n;
 534     CHECK_EQUAL( sscanf( string + 21, "%hi%n", &i, &n ), 1 );
 535     CHECK_EQUAL( i, -32768 );
 536     CHECK_EQUAL( n, 6 );
 537     }
 538     {
 539     // reading 32767, i
 540     signed short i = -1;
 541     int n;
 542     CHECK_EQUAL( sscanf( string + 29, "%hi%n", &i, &n ), 1 );
 543     CHECK_EQUAL( i, 32767 );
 544     CHECK_EQUAL( n, 5 );
 545     }
 546     {
 547     // reading +32767, i
 548     signed short i = -1;
 549     int n;
 550     CHECK_EQUAL( sscanf( string + 28, "%hi%n", &i, &n ), 1 );
 551     CHECK_EQUAL( i, 32767 );
 552     CHECK_EQUAL( n, 6 );
 553     }
 554     {
 555     // reading 0, d
 556     signed int i = -1;
 557     int n;
 558     CHECK_EQUAL( sscanf( string + 1, "%d%n", &i, &n ), 1 );
 559     CHECK_EQUAL( i, 0 );
 560     CHECK_EQUAL( n, 1 );
 561     }
 562     {
 563     // reading -0, d
 564     signed int i = -1;
 565     int n;
 566     CHECK_EQUAL( sscanf( string + 0, "%d%n", &i, &n ), 1 );
 567     CHECK_EQUAL( i, 0 );
 568     CHECK_EQUAL( n, 2 );
 569     }
 570     {
 571     // reading +0, d
 572     signed int i = -1;
 573     int n;
 574     CHECK_EQUAL( sscanf( string + 3, "%d%n", &i, &n ), 1 );
 575     CHECK_EQUAL( i, 0 );
 576     CHECK_EQUAL( n, 2 );
 577     }
 578     {
 579     // reading -2147483648, d
 580     signed int i = -1;
 581     int n;
 582     CHECK_EQUAL( sscanf( string + 42, "%d%n", &i, &n ), 1 );
 583     CHECK_EQUAL( i, -2147483648 );
 584     CHECK_EQUAL( n, 11 );
 585     }
 586     {
 587     // reading 2147483647, d
 588     signed int i = -1;
 589     int n;
 590     CHECK_EQUAL( sscanf( string + 55, "%d%n", &i, &n ), 1 );
 591     CHECK_EQUAL( i, 2147483647 );
 592     CHECK_EQUAL( n, 10 );
 593     }
 594     {
 595     // reading +2147483647, d
 596     signed int i = -1;
 597     int n;
 598     CHECK_EQUAL( sscanf( string + 54, "%d%n", &i, &n ), 1 );
 599     CHECK_EQUAL( i, 2147483647 );
 600     CHECK_EQUAL( n, 11 );
 601     }
 602     {
 603     // reading 0, u
 604     unsigned int i = -1;
 605     int n;
 606     CHECK_EQUAL( sscanf( string + 1, "%u%n", &i, &n ), 1 );
 607     CHECK_EQUAL( i, 0 );
 608     CHECK_EQUAL( n, 1 );
 609     }
 610     {
 611     // reading -0, u
 612     unsigned int i = -1;
 613     int n;
 614     CHECK_EQUAL( sscanf( string + 0, "%u%n", &i, &n ), 1 );
 615     CHECK_EQUAL( i, 0 );
 616     CHECK_EQUAL( n, 2 );
 617     }
 618     {
 619     // reading +0, u
 620     unsigned int i = -1;
 621     int n;
 622     CHECK_EQUAL( sscanf( string + 3, "%u%n", &i, &n ), 1 );
 623     CHECK_EQUAL( i, 0 );
 624     CHECK_EQUAL( n, 2 );
 625     }
 626     {
 627     // reading 2147483647, u
 628     unsigned int i = -1;
 629     int n;
 630     CHECK_EQUAL( sscanf( string + 55, "%u%n", &i, &n ), 1 );
 631     CHECK_EQUAL( i, 2147483647 );
 632     CHECK_EQUAL( n, 10 );
 633     }
 634     {
 635     // reading +2147483647, u
 636     unsigned int i = -1;
 637     int n;
 638     CHECK_EQUAL( sscanf( string + 54, "%u%n", &i, &n ), 1 );
 639     CHECK_EQUAL( i, 2147483647 );
 640     CHECK_EQUAL( n, 11 );
 641     }
 642     {
 643     // reading 4294967295, u
 644     unsigned int i = 0;
 645     int n;
 646     CHECK_EQUAL( sscanf( string + 67, "%u%n", &i, &n ), 1 );
 647     CHECK_FEQUAL( i, 4294967295, unsigned int, "%u" );
 648     CHECK_EQUAL( n, 10 );
 649     }
 650     {
 651     // reading +4294967295, u
 652     unsigned int i = 0;
 653     int n;
 654     CHECK_EQUAL( sscanf( string + 66, "%u%n", &i, &n ), 1 );
 655     CHECK_FEQUAL( i, 4294967295, unsigned int, "%u" );
 656     CHECK_EQUAL( n, 11 );
 657     }
 658     {
 659     // reading 0, i
 660     signed int i = -1;
 661     int n;
 662     CHECK_EQUAL( sscanf( string + 1, "%i%n", &i, &n ), 1 );
 663     CHECK_EQUAL( i, 0 );
 664     CHECK_EQUAL( n, 1 );
 665     }
 666     {
 667     // reading -0, i
 668     signed int i = -1;
 669     int n;
 670     CHECK_EQUAL( sscanf( string + 0, "%i%n", &i, &n ), 1 );
 671     CHECK_EQUAL( i, 0 );
 672     CHECK_EQUAL( n, 2 );
 673     }
 674     {
 675     // reading +0, i
 676     signed int i = -1;
 677     int n;
 678     CHECK_EQUAL( sscanf( string + 3, "%i%n", &i, &n ), 1 );
 679     CHECK_EQUAL( i, 0 );
 680     CHECK_EQUAL( n, 2 );
 681     }
 682     {
 683     // reading -2147483648, i
 684     signed int i = -1;
 685     int n;
 686     CHECK_EQUAL( sscanf( string + 42, "%i%n", &i, &n ), 1 );
 687     CHECK_EQUAL( i, -2147483648 );
 688     CHECK_EQUAL( n, 11 );
 689     }
 690     {
 691     // reading 2147483647, i
 692     signed int i = -1;
 693     int n;
 694     CHECK_EQUAL( sscanf( string + 55, "%i%n", &i, &n ), 1 );
 695     CHECK_EQUAL( i, 2147483647 );
 696     CHECK_EQUAL( n, 10 );
 697     }
 698     {
 699     // reading +2147483647, i
 700     signed int i = -1;
 701     int n;
 702     CHECK_EQUAL( sscanf( string + 54, "%i%n", &i, &n ), 1 );
 703     CHECK_EQUAL( i, 2147483647 );
 704     CHECK_EQUAL( n, 11 );
 705     }
 706     {
 707     // reading 0, d
 708     signed long i = -1;
 709     int n;
 710     CHECK_EQUAL( sscanf( string + 1, "%ld%n", &i, &n ), 1 );
 711     CHECK_EQUAL( i, 0l );
 712     CHECK_EQUAL( n, 1 );
 713     }
 714     {
 715     // reading -0, d
 716     signed long i = -1;
 717     int n;
 718     CHECK_EQUAL( sscanf( string + 0, "%ld%n", &i, &n ), 1 );
 719     CHECK_EQUAL( i, 0l );
 720     CHECK_EQUAL( n, 2 );
 721     }
 722     {
 723     // reading +0, d
 724     signed long i = -1;
 725     int n;
 726     CHECK_EQUAL( sscanf( string + 3, "%ld%n", &i, &n ), 1 );
 727     CHECK_EQUAL( i, 0l );
 728     CHECK_EQUAL( n, 2 );
 729     }
 730     {
 731     // reading -2147483648, d
 732     signed long i = -1;
 733     int n;
 734     CHECK_EQUAL( sscanf( string + 42, "%ld%n", &i, &n ), 1 );
 735     CHECK_EQUAL( i, -2147483648l );
 736     CHECK_EQUAL( n, 11 );
 737     }
 738     {
 739     // reading 2147483647, d
 740     signed long i = -1;
 741     int n;
 742     CHECK_EQUAL( sscanf( string + 55, "%ld%n", &i, &n ), 1 );
 743     CHECK_EQUAL( i, 2147483647l );
 744     CHECK_EQUAL( n, 10 );
 745     }
 746     {
 747     // reading +2147483647, d
 748     signed long i = -1;
 749     int n;
 750     CHECK_EQUAL( sscanf( string + 54, "%ld%n", &i, &n ), 1 );
 751     CHECK_EQUAL( i, 2147483647l );
 752     CHECK_EQUAL( n, 11 );
 753     }
 754     {
 755     // reading 0, u
 756     unsigned long i = -1;
 757     int n;
 758     CHECK_EQUAL( sscanf( string + 1, "%lu%n", &i, &n ), 1 );
 759     CHECK_EQUAL( i, 0ul );
 760     CHECK_EQUAL( n, 1 );
 761     }
 762     {
 763     // reading -0, u
 764     unsigned long i = -1;
 765     int n;
 766     CHECK_EQUAL( sscanf( string + 0, "%lu%n", &i, &n ), 1 );
 767     CHECK_EQUAL( i, 0ul );
 768     CHECK_EQUAL( n, 2 );
 769     }
 770     {
 771     // reading +0, u
 772     unsigned long i = -1;
 773     int n;
 774     CHECK_EQUAL( sscanf( string + 3, "%lu%n", &i, &n ), 1 );
 775     CHECK_EQUAL( i, 0ul );
 776     CHECK_EQUAL( n, 2 );
 777     }
 778     {
 779     // reading 2147483647, u
 780     unsigned long i = -1;
 781     int n;
 782     CHECK_EQUAL( sscanf( string + 55, "%lu%n", &i, &n ), 1 );
 783     CHECK_EQUAL( i, 2147483647ul );
 784     CHECK_EQUAL( n, 10 );
 785     }
 786     {
 787     // reading +2147483647, u
 788     unsigned long i = -1;
 789     int n;
 790     CHECK_EQUAL( sscanf( string + 54, "%lu%n", &i, &n ), 1 );
 791     CHECK_EQUAL( i, 2147483647ul );
 792     CHECK_EQUAL( n, 11 );
 793     }
 794     {
 795     // reading 4294967295, u
 796     unsigned long i = 0;
 797     int n;
 798     CHECK_EQUAL( sscanf( string + 67, "%lu%n", &i, &n ), 1 );
 799     CHECK_FEQUAL( i, 4294967295ul, unsigned long, "%lu" );
 800     CHECK_EQUAL( n, 10 );
 801     }
 802     {
 803     // reading +4294967295, u
 804     unsigned long i = 0;
 805     int n;
 806     CHECK_EQUAL( sscanf( string + 66, "%lu%n", &i, &n ), 1 );
 807     CHECK_FEQUAL( i, 4294967295ul, unsigned long, "%lu" );
 808     CHECK_EQUAL( n, 11 );
 809     }
 810     {
 811     // reading 0, i
 812     signed long i = -1;
 813     int n;
 814     CHECK_EQUAL( sscanf( string + 1, "%li%n", &i, &n ), 1 );
 815     CHECK_EQUAL( i, 0l );
 816     CHECK_EQUAL( n, 1 );
 817     }
 818     {
 819     // reading -0, i
 820     signed long i = -1;
 821     int n;
 822     CHECK_EQUAL( sscanf( string + 0, "%li%n", &i, &n ), 1 );
 823     CHECK_EQUAL( i, 0l );
 824     CHECK_EQUAL( n, 2 );
 825     }
 826     {
 827     // reading +0, i
 828     signed long i = -1;
 829     int n;
 830     CHECK_EQUAL( sscanf( string + 3, "%li%n", &i, &n ), 1 );
 831     CHECK_EQUAL( i, 0l );
 832     CHECK_EQUAL( n, 2 );
 833     }
 834     {
 835     // reading -2147483648, i
 836     signed long i = -1;
 837     int n;
 838     CHECK_EQUAL( sscanf( string + 42, "%li%n", &i, &n ), 1 );
 839     CHECK_EQUAL( i, -2147483648l );
 840     CHECK_EQUAL( n, 11 );
 841     }
 842     {
 843     // reading 2147483647, i
 844     signed long i = -1;
 845     int n;
 846     CHECK_EQUAL( sscanf( string + 55, "%li%n", &i, &n ), 1 );
 847     CHECK_EQUAL( i, 2147483647l );
 848     CHECK_EQUAL( n, 10 );
 849     }
 850     {
 851     // reading +2147483647, i
 852     signed long i = -1;
 853     int n;
 854     CHECK_EQUAL( sscanf( string + 54, "%li%n", &i, &n ), 1 );
 855     CHECK_EQUAL( i, 2147483647l );
 856     CHECK_EQUAL( n, 11 );
 857     }
 858     {
 859     // reading 0, d
 860     signed long long i = -1;
 861     int n;
 862     CHECK_EQUAL( sscanf( string + 1, "%lld%n", &i, &n ), 1 );
 863     CHECK_EQUAL( i, 0ll );
 864     CHECK_EQUAL( n, 1 );
 865     }
 866     {
 867     // reading -0, d
 868     signed long long i = -1;
 869     int n;
 870     CHECK_EQUAL( sscanf( string + 0, "%lld%n", &i, &n ), 1 );
 871     CHECK_EQUAL( i, 0ll );
 872     CHECK_EQUAL( n, 2 );
 873     }
 874     {
 875     // reading +0, d
 876     signed long long i = -1;
 877     int n;
 878     CHECK_EQUAL( sscanf( string + 3, "%lld%n", &i, &n ), 1 );
 879     CHECK_EQUAL( i, 0ll );
 880     CHECK_EQUAL( n, 2 );
 881     }
 882     {
 883     // reading -9223372036854775808, d
 884     signed long long i = -1;
 885     int n;
 886     CHECK_EQUAL( sscanf( string + 78, "%lld%n", &i, &n ), 1 );
 887     CHECK_FEQUAL( i, LLONG_MIN, signed long long, "%lld" ); // should be literal -9223372036854775808ll but GCC balks.
 888     CHECK_EQUAL( i < 0ll, 1 );
 889     CHECK_EQUAL( n, 20 );
 890     }
 891     {
 892     // reading 9223372036854775807, d
 893     signed long long i = -1;
 894     int n;
 895     CHECK_EQUAL( sscanf( string + 100, "%lld%n", &i, &n ), 1 );
 896     CHECK_FEQUAL( i, 9223372036854775807ll, signed long long, "%lld" );
 897     CHECK_EQUAL( n, 19 );
 898     }
 899     {
 900     // reading +9223372036854775807, d
 901     signed long long i = -1;
 902     int n;
 903     CHECK_EQUAL( sscanf( string + 99, "%lld%n", &i, &n ), 1 );
 904     CHECK_FEQUAL( i, 9223372036854775807ll, signed long long, "%lld" );
 905     CHECK_EQUAL( n, 20 );
 906     }
 907     {
 908     // reading 0, u
 909     unsigned long long i = -1;
 910     int n;
 911     CHECK_EQUAL( sscanf( string + 1, "%llu%n", &i, &n ), 1 );
 912     CHECK_EQUAL( i, 0ull );
 913     CHECK_EQUAL( n, 1 );
 914     }
 915     {
 916     // reading -0, u
 917     unsigned long long i = -1;
 918     int n;
 919     CHECK_EQUAL( sscanf( string + 0, "%llu%n", &i, &n ), 1 );
 920     CHECK_EQUAL( i, 0ull );
 921     CHECK_EQUAL( n, 2 );
 922     }
 923     {
 924     // reading +0, u
 925     unsigned long long i = -1;
 926     int n;
 927     CHECK_EQUAL( sscanf( string + 3, "%llu%n", &i, &n ), 1 );
 928     CHECK_EQUAL( i, 0ull );
 929     CHECK_EQUAL( n, 2 );
 930     }
 931     {
 932     // reading 9223372036854775807, u
 933     unsigned long long i = -1;
 934     int n;
 935     CHECK_EQUAL( sscanf( string + 100, "%llu%n", &i, &n ), 1 );
 936     CHECK_FEQUAL( i, 9223372036854775807ull, unsigned long long, "%llu" );
 937     CHECK_EQUAL( n, 19 );
 938     }
 939     {
 940     // reading +9223372036854775807, u
 941     unsigned long long i = -1;
 942     int n;
 943     CHECK_EQUAL( sscanf( string + 99, "%llu%n", &i, &n ), 1 );
 944     CHECK_FEQUAL( i, 9223372036854775807ull, unsigned long long, "%llu" );
 945     CHECK_EQUAL( n, 20 );
 946     }
 947     {
 948     // reading 18446744073709551615, u
 949     unsigned long long i = 0;
 950     int n;
 951     CHECK_EQUAL( sscanf( string + 121, "%llu%n", &i, &n ), 1 );
 952     CHECK_FEQUAL( i, 18446744073709551615ull, unsigned long long, "%llu" );
 953     CHECK_EQUAL( n, 20 );
 954     }
 955     {
 956     // reading +18446744073709551615, u
 957     unsigned long long i = 0;
 958     int n;
 959     CHECK_EQUAL( sscanf( string + 120, "%llu%n", &i, &n ), 1 );
 960     CHECK_FEQUAL( i, 18446744073709551615ull, unsigned long long, "%llu" );
 961     CHECK_EQUAL( n, 21 );
 962     }
 963     {
 964     // reading 0, i
 965     signed long long i = -1;
 966     int n;
 967     CHECK_EQUAL( sscanf( string + 1, "%lli%n", &i, &n ), 1 );
 968     CHECK_EQUAL( i, 0ll );
 969     CHECK_EQUAL( n, 1 );
 970     }
 971     {
 972     // reading -0, i
 973     signed long long i = -1;
 974     int n;
 975     CHECK_EQUAL( sscanf( string + 0, "%lli%n", &i, &n ), 1 );
 976     CHECK_EQUAL( i, 0ll );
 977     CHECK_EQUAL( n, 2 );
 978     }
 979     {
 980     // reading +0, i
 981     signed long long i = -1;
 982     int n;
 983     CHECK_EQUAL( sscanf( string + 3, "%lli%n", &i, &n ), 1 );
 984     CHECK_EQUAL( i, 0ll );
 985     CHECK_EQUAL( n, 2 );
 986     }
 987     {
 988     // reading -9223372036854775808, i
 989     signed long long i = -1;
 990     int n;
 991     CHECK_EQUAL( sscanf( string + 78, "%lli%n", &i, &n ), 1 );
 992     CHECK_FEQUAL( i, LLONG_MIN, signed long long, "%lli" ); // should be literal -9223372036854775808ll but GCC balks.
 993     CHECK_EQUAL( i < 0ll, 1 );
 994     CHECK_EQUAL( n, 20 );
 995     }
 996     {
 997     // reading 9223372036854775807, i
 998     signed long long i = -1;
 999     int n;
1000     CHECK_EQUAL( sscanf( string + 100, "%lli%n", &i, &n ), 1 );
1001     CHECK_FEQUAL( i, 9223372036854775807ll, signed long long, "%lli" );
1002     CHECK_EQUAL( n, 19 );
1003     }
1004     {
1005     // reading +9223372036854775807, i
1006     signed long long i = -1;
1007     int n;
1008     CHECK_EQUAL( sscanf( string + 99, "%lli%n", &i, &n ), 1 );
1009     CHECK_FEQUAL( i, 9223372036854775807ll, signed long long, "%lli" );
1010     CHECK_EQUAL( n, 20 );
1011     }
1012 }
1013
1014 // hexadecimal integer matches
1015 void suite_three()
1016 {
1017     char const * string = "-0x0 -0x000 -0x7f 0x80 0xff -0x7fff 0x8000\n"
1018                           "0xffff -0x7fffffff 0x80000000 0xffffffff\n"
1019                           "-0x7fffffffffffffff 0x8000000000000000\n"
1020                           "0xffffffffffffffff -0x\n";
1021     CHECK_EQUAL( string[145], '\n' );
1022     {
1023     // reading 0, x
1024     unsigned char i = -1;
1025     int n;
1026     CHECK_EQUAL( sscanf( string + 3, "%hhx%n", &i, &n ), 1 );
1027     CHECK_EQUAL( i, 0 );
1028     CHECK_EQUAL( n, 1 );
1029     }
1030     {
1031     // reading -0x0, x
1032     unsigned char i = -1;
1033     int n;
1034     CHECK_EQUAL( sscanf( string + 0, "%hhx%n", &i, &n ), 1 );
1035     CHECK_EQUAL( i, 0 );
1036     CHECK_EQUAL( n, 4 );
1037     }
1038     {
1039     // reading -0x, x
1040     unsigned char i = -1;
1041     int n;
1042     CHECK_EQUAL( sscanf( string + 142, "%hhx%n", &i, &n ), 1 );
1043     CHECK_EQUAL( i, 0 );
1044     CHECK_EQUAL( n, 3 );
1045     }
1046     {
1047     // reading 0x000, x
1048     unsigned char i = -1;
1049     int n;
1050     CHECK_EQUAL( sscanf( string + 5, "%hhx%n", &i, &n ), 1 );
1051     CHECK_EQUAL( i, 0 );
1052     CHECK_EQUAL( n, 6 );
1053     }
1054     {
1055     // reading 0x0, i
1056     signed char i = -1;
1057     int n;
1058     CHECK_EQUAL( sscanf( string + 0, "%hhi%n", &i, &n ), 1 );
1059     CHECK_EQUAL( i, 0 );
1060     CHECK_EQUAL( n, 4 );
1061     }
1062     {
1063     // reading 7f, x
1064     unsigned char i = -1;
1065     int n;
1066     CHECK_EQUAL( sscanf( string + 15, "%hhx%n", &i, &n ), 1 );
1067     CHECK_EQUAL( i, 127 );
1068     CHECK_EQUAL( n, 2 );
1069     }
1070     {
1071     // reading -0x7f, x
1072     unsigned char i = -1;
1073     int n;
1074     CHECK_EQUAL( sscanf( string + 12, "%hhx%n", &i, &n ), 1 );
1075     CHECK_FEQUAL( i, -127, unsigned char, "%hhu" );
1076     CHECK_EQUAL( n, 5 );
1077     }
1078     {
1079     // reading 0x80, i
1080     signed char i = -1;
1081     int n;
1082     CHECK_EQUAL( sscanf( string + 18, "%hhi%n", &i, &n ), 1 );
1083     CHECK_FEQUAL( i, -128, signed char, "%hd" );
1084     CHECK_EQUAL( n, 4 );
1085     }
1086     {
1087     // reading ff, x
1088     unsigned char i = -1;
1089     int n;
1090     CHECK_EQUAL( sscanf( string + 25, "%hhx%n", &i, &n ), 1 );
1091     CHECK_EQUAL( i, 0xff );
1092     CHECK_EQUAL( n, 2 );
1093     }
1094     {
1095     // reading 0xff, x
1096     unsigned char i = -1;
1097     int n;
1098     CHECK_EQUAL( sscanf( string + 23, "%hhx%n", &i, &n ), 1 );
1099     CHECK_EQUAL( i, 255 );
1100     CHECK_EQUAL( n, 4 );
1101     }
1102     {
1103     // reading 0xff, i
1104     signed char i = 0;
1105     int n;
1106     CHECK_EQUAL( sscanf( string + 23, "%hhi%n", &i, &n ), 1 );
1107     CHECK_EQUAL( i, -1 );
1108     CHECK_EQUAL( n, 4 );
1109     }
1110     {
1111     // reading 0, x
1112     unsigned short i = -1;
1113     int n;
1114     CHECK_EQUAL( sscanf( string + 3, "%hx%n", &i, &n ), 1 );
1115     CHECK_EQUAL( i, 0 );
1116     CHECK_EQUAL( n, 1 );
1117     }
1118     {
1119     // reading -0x0, x
1120     unsigned short i = -1;
1121     int n;
1122     CHECK_EQUAL( sscanf( string + 0, "%hx%n", &i, &n ), 1 );
1123     CHECK_EQUAL( i, 0 );
1124     CHECK_EQUAL( n, 4 );
1125     }
1126     {
1127     // reading -0x, x
1128     unsigned short i = -1;
1129     int n;
1130     CHECK_EQUAL( sscanf( string + 142, "%hx%n", &i, &n ), 1 );
1131     CHECK_EQUAL( i, 0 );
1132     CHECK_EQUAL( n, 3 );
1133     }
1134     {
1135     // reading 0x000, x
1136     unsigned short i = -1;
1137     int n;
1138     CHECK_EQUAL( sscanf( string + 5, "%hx%n", &i, &n ), 1 );
1139     CHECK_EQUAL( i, 0 );
1140     CHECK_EQUAL( n, 6 );
1141     }
1142     {
1143     // reading 0x0, i
1144     signed short i = -1;
1145     int n;
1146     CHECK_EQUAL( sscanf( string + 0, "%hi%n", &i, &n ), 1 );
1147     CHECK_EQUAL( i, 0 );
1148     CHECK_EQUAL( n, 4 );
1149     }
1150     {
1151     // reading 7fff, x
1152     unsigned short i = -1;
1153     int n;
1154     CHECK_EQUAL( sscanf( string + 31, "%hx%n", &i, &n ), 1 );
1155     CHECK_EQUAL( i, 32767 );
1156     CHECK_EQUAL( n, 4 );
1157     }
1158     {
1159     // reading -0x7fff, x
1160     unsigned short i = -1;
1161     int n;
1162     CHECK_EQUAL( sscanf( string + 28, "%hx%n", &i, &n ), 1 );
1163     CHECK_FEQUAL( i, -32767, unsigned short, "%hu" );
1164     CHECK_EQUAL( n, 7 );
1165     }
1166     {
1167     // reading 0x8000, i
1168     signed short i = -1;
1169     int n;
1170     CHECK_EQUAL( sscanf( string + 36, "%hi%n", &i, &n ), 1 );
1171     CHECK_FEQUAL( i, -32768, signed short, "%hd" );
1172     CHECK_EQUAL( n, 6 );
1173     }
1174     {
1175     // reading ffff, x
1176     unsigned short i = -1;
1177     int n;
1178     CHECK_EQUAL( sscanf( string + 45, "%hx%n", &i, &n ), 1 );
1179     CHECK_EQUAL( i, 65535 );
1180     CHECK_EQUAL( n, 4 );
1181     }
1182     {
1183     // reading 0xffff, x
1184     unsigned short i = -1;
1185     int n;
1186     CHECK_EQUAL( sscanf( string + 43, "%hx%n", &i, &n ), 1 );
1187     CHECK_EQUAL( i, 65535 );
1188     CHECK_EQUAL( n, 6 );
1189     }
1190     {
1191     // reading 0xffff, i
1192     signed short i = 0;
1193     int n;
1194     CHECK_EQUAL( sscanf( string + 43, "%hi%n", &i, &n ), 1 );
1195     CHECK_FEQUAL( i, -1, signed short, "%hd" );
1196     CHECK_EQUAL( n, 6 );
1197     }
1198     {
1199     // reading 0, x
1200     unsigned int i = -1;
1201     int n;
1202     CHECK_EQUAL( sscanf( string + 3, "%x%n", &i, &n ), 1 );
1203     CHECK_EQUAL( i, 0 );
1204     CHECK_EQUAL( n, 1 );
1205     }
1206     {
1207     // reading -0x0, x
1208     unsigned int i = -1;
1209     int n;
1210     CHECK_EQUAL( sscanf( string + 0, "%x%n", &i, &n ), 1 );
1211     CHECK_EQUAL( i, 0 );
1212     CHECK_EQUAL( n, 4 );
1213     }
1214     {
1215     // reading -0x, x
1216     unsigned int i = -1;
1217     int n;
1218     CHECK_EQUAL( sscanf( string + 142, "%x%n", &i, &n ), 1 );
1219     CHECK_EQUAL( i, 0 );
1220     CHECK_EQUAL( n, 3 );
1221     }
1222     {
1223     // reading 0x000, x
1224     unsigned int i = -1;
1225     int n;
1226     CHECK_EQUAL( sscanf( string + 5, "%x%n", &i, &n ), 1 );
1227     CHECK_EQUAL( i, 0 );
1228     CHECK_EQUAL( n, 6 );
1229     }
1230     {
1231     // reading 0x0, i
1232     signed int i = -1;
1233     int n;
1234     CHECK_EQUAL( sscanf( string + 0, "%i%n", &i, &n ), 1 );
1235     CHECK_EQUAL( i, 0 );
1236     CHECK_EQUAL( n, 4 );
1237     }
1238     {
1239     // reading 7fffffff, x
1240     unsigned int i = -1;
1241     int n;
1242     CHECK_EQUAL( sscanf( string + 53, "%x%n", &i, &n ), 1 );
1243     CHECK_EQUAL( i, 2147483647 );
1244     CHECK_EQUAL( n, 8 );
1245     }
1246     {
1247     // reading -0x7fffffff, x
1248     unsigned int i = -1;
1249     int n;
1250     CHECK_EQUAL( sscanf( string + 50, "%x%n", &i, &n ), 1 );
1251     CHECK_FEQUAL( i, -2147483647, unsigned int, "%u" );
1252     CHECK_EQUAL( n, 11 );
1253     }
1254     {
1255     // reading 0x80000000, i
1256     signed int i = -1;
1257     int n;
1258     CHECK_EQUAL( sscanf( string + 62, "%i%n", &i, &n ), 1 );
1259     CHECK_FEQUAL( i, 2147483647, signed int, "%d" ); // NOT overflowing, see strtol() specs.
1260     CHECK_EQUAL( n, 10 );
1261     }
1262     {
1263     // reading ffffffff, x
1264     unsigned int i = -1;
1265     int n;
1266     CHECK_EQUAL( sscanf( string + 75, "%x%n", &i, &n ), 1 );
1267     CHECK_FEQUAL( i, 4294967295, unsigned int, "%d" );
1268     CHECK_EQUAL( n, 8 );
1269     }
1270     {
1271     // reading 0xffffffff, x
1272     unsigned int i = -1;
1273     int n;
1274     CHECK_EQUAL( sscanf( string + 73, "%x%n", &i, &n ), 1 );
1275     CHECK_FEQUAL( i, 4294967295, unsigned int, "%d" );
1276     CHECK_EQUAL( n, 10 );
1277     }
1278     {
1279     // reading 0xffffffff, i
1280     signed int i = 0;
1281     int n;
1282     CHECK_EQUAL( sscanf( string + 73, "%i%n", &i, &n ), 1 );
1283     CHECK_FEQUAL( i, 2147483647, signed int, "%d" ); // NOT overflowing; see strtol() specs.
1284     CHECK_EQUAL( n, 10 );
1285     }
1286 }
1287
1288 // octal integer matches
1289 void suite_four()
1290 {
1291     char const * string = "+0000 -0000 +0177 +0377 -0377 +077777 +0177777\n"
1292                           "-0177777 +017777777777 +037777777777\n"
1293                           "-037777777777 +0777777777777777777777\n"
1294                           "+01777777777777777777777\n"
1295                           "-01777777777777777777777\n";
1296     CHECK_EQUAL( string[171], '\n' );
1297     {
1298     // reading 0, o
1299     unsigned char i = -1;
1300     int n;
1301     CHECK_EQUAL( sscanf( string + 4, "%hho%n", &i, &n ), 1 );
1302     CHECK_EQUAL( i, 0u );
1303     CHECK_EQUAL( n, 1 );
1304     }
1305     {
1306     // reading +0000, o
1307     unsigned char i = -1;
1308     int n;
1309     CHECK_EQUAL( sscanf( string + 0, "%hho%n", &i, &n ), 1 );
1310     CHECK_EQUAL( i, 0u );
1311     CHECK_EQUAL( n, 5 );
1312     }
1313     {
1314     // reading -0000, o
1315     unsigned char i = -1;
1316     int n;
1317     CHECK_EQUAL( sscanf( string + 6, "%hho%n", &i, &n ), 1 );
1318     CHECK_EQUAL( i, 0u );
1319     CHECK_EQUAL( n, 5 );
1320     }
1321     {
1322     // reading 0177, o
1323     unsigned char i = -1;
1324     int n;
1325     CHECK_EQUAL( sscanf( string + 13, "%hho%n", &i, &n ), 1 );
1326     CHECK_EQUAL( i, 127u );
1327     CHECK_EQUAL( n, 4 );
1328     }
1329     {
1330     // reading +0177, o
1331     unsigned char i = -1;
1332     int n;
1333     CHECK_EQUAL( sscanf( string + 12, "%hho%n", &i, &n ), 1 );
1334     CHECK_EQUAL( i, 127u );
1335     CHECK_EQUAL( n, 5 );
1336     }
1337     {
1338     // reading 0377, o
1339     unsigned char i = -1;
1340     int n;
1341     CHECK_EQUAL( sscanf( string + 19, "%hho%n", &i, &n ), 1 );
1342     CHECK_FEQUAL( i, 255u, unsigned char, "%hhu" );
1343     CHECK_EQUAL( n, 4 );
1344     }
1345     {
1346     // reading +0377, o
1347     unsigned char i = -1;
1348     int n;
1349     CHECK_EQUAL( sscanf( string + 18, "%hho%n", &i, &n ), 1 );
1350     CHECK_FEQUAL( i, 255u, unsigned char, "%hhu" );
1351     CHECK_EQUAL( n, 5 );
1352     }
1353     {
1354     // reading -0377, o
1355     unsigned char i = -1;
1356     int n;
1357     CHECK_EQUAL( sscanf( string + 24, "%hho%n", &i, &n ), 1 );
1358     CHECK_FEQUAL( i, 1u, unsigned char, "%hhu" );
1359     CHECK_EQUAL( n, 5 );
1360     }
1361     {
1362     // reading 077777, o
1363     unsigned short i = -1;
1364     int n;
1365     CHECK_EQUAL( sscanf( string + 31, "%ho%n", &i, &n ), 1 );
1366     CHECK_EQUAL( i, 32767u );
1367     CHECK_EQUAL( n, 6 );
1368     }
1369     {
1370     // reading +077777, o
1371     unsigned short i = -1;
1372     int n;
1373     CHECK_EQUAL( sscanf( string + 30, "%ho%n", &i, &n ), 1 );
1374     CHECK_EQUAL( i, 32767u );
1375     CHECK_EQUAL( n, 7 );
1376     }
1377     {
1378     // reading 0177777, o
1379     unsigned short i = -1;
1380     int n;
1381     CHECK_EQUAL( sscanf( string + 39, "%ho%n", &i, &n ), 1 );
1382     CHECK_FEQUAL( i, 65535u, unsigned short, "%hu" );
1383     CHECK_EQUAL( n, 7 );
1384     }
1385     {
1386     // reading +0177777, o
1387     unsigned short i = -1;
1388     int n;
1389     CHECK_EQUAL( sscanf( string + 38, "%ho%n", &i, &n ), 1 );
1390     CHECK_FEQUAL( i, 65535u, unsigned short, "%hu" );
1391     CHECK_EQUAL( n, 8 );
1392     }
1393     {
1394     // reading -0177777, o
1395     unsigned short i = -1;
1396     int n;
1397     CHECK_EQUAL( sscanf( string + 47, "%ho%n", &i, &n ), 1 );
1398     CHECK_FEQUAL( i, 1u, unsigned short, "%hu" );
1399     CHECK_EQUAL( n, 8 );
1400     }
1401     {
1402     // reading 017777777777, o
1403     unsigned int i = -1;
1404     int n;
1405     CHECK_EQUAL( sscanf( string + 57, "%o%n", &i, &n ), 1 );
1406     CHECK_EQUAL( i, 2147483647u );
1407     CHECK_EQUAL( n, 12 );
1408     }
1409     {
1410     // reading +017777777777, o
1411     unsigned int i = -1;
1412     int n;
1413     CHECK_EQUAL( sscanf( string + 56, "%o%n", &i, &n ), 1 );
1414     CHECK_EQUAL( i, 2147483647u );
1415     CHECK_EQUAL( n, 13 );
1416     }
1417     {
1418     // reading 037777777777, o
1419     unsigned int i = -1;
1420     int n;
1421     CHECK_EQUAL( sscanf( string + 71, "%o%n", &i, &n ), 1 );
1422     CHECK_FEQUAL( i, 4294967295u, unsigned int, "%u" );
1423     CHECK_EQUAL( n, 12 );
1424     }
1425     {
1426     // reading +037777777777, o
1427     unsigned int i = -1;
1428     int n;
1429     CHECK_EQUAL( sscanf( string + 70, "%o%n", &i, &n ), 1 );
1430     CHECK_FEQUAL( i, 4294967295u, unsigned int, "%u" );
1431     CHECK_EQUAL( n, 13 );
1432     }
1433     {
1434     // reading -037777777777, o
1435     unsigned int i = -1;
1436     int n;
1437     CHECK_EQUAL( sscanf( string + 84, "%o%n", &i, &n ), 1 );
1438     CHECK_FEQUAL( i, 1u, unsigned int, "%u" );
1439     CHECK_EQUAL( n, 13 );
1440     }
1441     {
1442     // reading 017777777777, o
1443     unsigned long i = -1;
1444     int n;
1445     CHECK_EQUAL( sscanf( string + 57, "%lo%n", &i, &n ), 1 );
1446     CHECK_EQUAL( i, 2147483647lu );
1447     CHECK_EQUAL( n, 12 );
1448     }
1449     {
1450     // reading +017777777777, o
1451     unsigned long i = -1;
1452     int n;
1453     CHECK_EQUAL( sscanf( string + 56, "%lo%n", &i, &n ), 1 );
1454     CHECK_EQUAL( i, 2147483647lu );
1455     CHECK_EQUAL( n, 13 );
1456     }
1457     {
1458     // reading 037777777777, o
1459     unsigned long i = -1;
1460     int n;
1461     CHECK_EQUAL( sscanf( string + 71, "%lo%n", &i, &n ), 1 );
1462     CHECK_FEQUAL( i, 4294967295lu, unsigned long, "%lu" );
1463     CHECK_EQUAL( n, 12 );
1464     }
1465     {
1466     // reading +037777777777, o
1467     unsigned long i = -1;
1468     int n;
1469     CHECK_EQUAL( sscanf( string + 70, "%lo%n", &i, &n ), 1 );
1470     CHECK_FEQUAL( i, 4294967295lu, unsigned long, "%lu" );
1471     CHECK_EQUAL( n, 13 );
1472     }
1473     {
1474     // reading -037777777777, o
1475     unsigned long i = -1;
1476     int n;
1477     CHECK_EQUAL( sscanf( string + 84, "%lo%n", &i, &n ), 1 );
1478     CHECK_FEQUAL( i, 1lu, unsigned long, "%lu" );
1479     CHECK_EQUAL( n, 13 );
1480     }
1481     {
1482     // reading 0777777777777777777777, o
1483     unsigned long long i = -1;
1484     int n;
1485     CHECK_EQUAL( sscanf( string + 99, "%llo%n", &i, &n ), 1 );
1486     CHECK_FEQUAL( i, 9223372036854775807llu, unsigned long long, "%llu" );
1487     CHECK_EQUAL( n, 22 );
1488     }
1489     {
1490     // reading +0777777777777777777777, o
1491     unsigned long long i = -1;
1492     int n;
1493     CHECK_EQUAL( sscanf( string + 98, "%llo%n", &i, &n ), 1 );
1494     CHECK_FEQUAL( i, 9223372036854775807llu, unsigned long long, "%llu" );
1495     CHECK_EQUAL( n, 23 );
1496     }
1497     {
1498     // reading 01777777777777777777777, o
1499     unsigned long long i = -1;
1500     int n;
1501     CHECK_EQUAL( sscanf( string + 123, "%llo%n", &i, &n ), 1 );
1502     CHECK_FEQUAL( i, 18446744073709551615llu, unsigned long long, "%llu" );
1503     CHECK_EQUAL( n, 23 );
1504     }
1505     {
1506     // reading +01777777777777777777777, o
1507     unsigned long long i = -1;
1508     int n;
1509     CHECK_EQUAL( sscanf( string + 122, "%llo%n", &i, &n ), 1 );
1510     CHECK_FEQUAL( i, 18446744073709551615llu, unsigned long long, "%llu" );
1511     CHECK_EQUAL( n, 24 );
1512     }
1513     {
1514     // reading -01777777777777777777777, o
1515     unsigned long long i = -1;
1516     int n;
1517     CHECK_EQUAL( sscanf( string + 147, "%llo%n", &i, &n ), 1 );
1518     CHECK_FEQUAL( i, 1llu, unsigned long long, "%llu" );
1519     CHECK_EQUAL( n, 24 );
1520     }
1521 }
1522
1523 // string matches
1524 void suite_five()
1525 {
1526     char const * string = "abcdefgh-ijklmnop[qrs%uvw]xyz";
1527     CHECK_EQUAL( string[28], 'z' );
1528     size_t const BUFSIZE = 29;
1529     char buffer[ BUFSIZE ];
1530     {
1531     // reading abc
1532     memset( buffer, '\0', BUFSIZE );
1533     int n;
1534     CHECK_EQUAL( sscanf( string + 0, "%[abc]%n", buffer, &n ), 1 );
1535     CHECK_EQUAL( n, 3 );
1536     CHECK_FALSE( memcmp( buffer, "abc", n + 1 ) );
1537     }
1538     {
1539     // reading a-c
1540     memset( buffer, '\0', BUFSIZE );
1541     int n;
1542     CHECK_EQUAL( sscanf( string + 0, "%[a-c]%n", buffer, &n ), 1 );
1543     CHECK_EQUAL( n, 3 );
1544     CHECK_FALSE( memcmp( buffer, "abc", n + 1 ) );
1545     }
1546     {
1547     // reading a-h
1548     memset( buffer, '\0', BUFSIZE );
1549     int n;
1550     CHECK_EQUAL( sscanf( string + 0, "%[a-h]%n", buffer, &n ), 1 );
1551     CHECK_EQUAL( n, 8 );
1552     CHECK_FALSE( memcmp( buffer, "abcdefgh", n + 1 ) );
1553     }
1554     {
1555     // reading o-r, including [, seperate char
1556     memset( buffer, '\0', BUFSIZE );
1557     int n;
1558     CHECK_EQUAL( sscanf( string + 15, "%[[o-qr]%n", buffer, &n ), 1 );
1559     CHECK_EQUAL( n, 5 );
1560     CHECK_FALSE( memcmp( buffer, "op[qr", n + 1 ) );
1561     }
1562     {
1563     // reading v-y, including ], two groups
1564     memset( buffer, '\0', BUFSIZE );
1565     int n;
1566     CHECK_EQUAL( sscanf( string + 23, "%[]v-wx-y]%n", buffer, &n ), 1 );
1567     CHECK_EQUAL( n, 5 );
1568     CHECK_FALSE( memcmp( buffer, "vw]xy", n + 1 ) );
1569     }
1570     {
1571     // missing on first character
1572     memset( buffer, '\0', BUFSIZE );
1573     int n;
1574     CHECK_EQUAL( sscanf( string + 0, "%[b]%n", buffer, &n ), 0 );
1575     CHECK_FALSE( memcmp( buffer, "", 1 ) );
1576     }
1577     {
1578     // eof while reading, two groups
1579     memset( buffer, '\0', BUFSIZE );
1580     int n;
1581     CHECK_EQUAL( sscanf( string + 27, "%[a-zA-Z]%n", buffer, &n ), 1 );
1582     CHECK_EQUAL( n, 2 );
1583     CHECK_FALSE( memcmp( buffer, "yz", n + 1 ) );
1584     }
1585     {
1586     // eof before reading
1587     memset( buffer, '\0', BUFSIZE );
1588     int n;
1589     CHECK_EQUAL( sscanf( string + 29, "%[a-z]%n", buffer, &n ), -1 );
1590     CHECK_FALSE( memcmp( buffer, "", 1 ) );
1591     }
1592     {
1593     // negation - [^...]
1594     memset( buffer, '\0', BUFSIZE );
1595     int n;
1596     CHECK_EQUAL( sscanf( string + 0, "%[^d-f]%n", buffer, &n ), 1 );
1597     CHECK_EQUAL( n, 3 );
1598     CHECK_FALSE( memcmp( buffer, "abc", 4 ) );
1599     }
1600 }
1601
1602 #endif