stdio-common/tst-scanf-intn-main.c

   1 /* Test scanf formats for intN_t, int_leastN_t and int_fastN_t types.
   2    Copyright (C) 2023-2024 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <stdint.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <wchar.h>
  24
  25 #include <libc-diag.h>
  26 #include <support/check.h>
  27
  28 /* GCC does not know the %wN or %wfN length modifiers before GCC 13.  */
  29 DIAG_PUSH_NEEDS_COMMENT;
  30 #if !__GNUC_PREREQ (13, 0)
  31 DIAG_IGNORE_NEEDS_COMMENT (12, "-Wformat");
  32 DIAG_IGNORE_NEEDS_COMMENT (12, "-Wformat-extra-args");
  33 #endif
  34
  35 #define CHECK_SCANF1(EXPECTED, STR, FMT)                                \
  36   do                                                                    \
  37     {                                                                   \
  38       var = ((typeof (var)) 0xabababab);                                \
  39       int ret = SSCANF (L_(STR), L_(FMT), &var);                        \
  40       TEST_COMPARE (var, (EXPECTED));                                   \
  41       TEST_COMPARE (ret, 1);                                            \
  42     }                                                                   \
  43   while (0)
  44
  45 #define CHECK_SCANF1N(EXPECTED, STR, FMT)                               \
  46   do                                                                    \
  47     {                                                                   \
  48       var = ((typeof (var)) 0xabababab);                                \
  49       n = 123;                                                          \
  50       int ret = SSCANF (L_(STR), L_(FMT), &var, &n);                    \
  51       TEST_COMPARE (var, (EXPECTED));                                   \
  52       TEST_COMPARE (n, STRLEN (L_(STR)));                               \
  53       TEST_COMPARE (ret, 1);                                            \
  54     }                                                                   \
  55   while (0)
  56
  57 #define CHECK_SCANF_ERR(OK, STR, FMT, ...)                              \
  58   do                                                                    \
  59     {                                                                   \
  60       int ret = SSCANF (L_(STR), L_(FMT), __VA_ARGS__);                 \
  61       TEST_VERIFY (ret == (OK));                                        \
  62       TEST_COMPARE (errno, EINVAL);                                     \
  63     }                                                                   \
  64   while (0)
  65
  66 static void
  67 test_w8 (void)
  68 {
  69   {
  70     int8_t var, n;
  71     CHECK_SCANF1 (42, "42", "%w8d");
  72     CHECK_SCANF1N (42, "42", "%w8d%w8n");
  73     CHECK_SCANF1 (-43, "-43", "%w8d");
  74     CHECK_SCANF1 (42, "42", "%w8i");
  75     CHECK_SCANF1 (-43, "-43", "%w8i");
  76     CHECK_SCANF1 (123, "0b1111011", "%w8i");
  77     CHECK_SCANF1 (127, "0x7f", "%w8i");
  78     CHECK_SCANF1 (-19, "-023", "%w8i");
  79   }
  80   {
  81     uint8_t var;
  82     int8_t n;
  83     CHECK_SCANF1 (123, "1111011", "%w8b");
  84     CHECK_SCANF1 (19, "023", "%w8o");
  85     CHECK_SCANF1 (50, "50", "%w8u");
  86     CHECK_SCANF1 (65, "41", "%w8x");
  87     CHECK_SCANF1N (65, "41", "%w8x%w8n");
  88     CHECK_SCANF1 (66, "42", "%w8X");
  89   }
  90   {
  91     int_least8_t var, n;
  92     CHECK_SCANF1 (42, "42", "%w8d");
  93     CHECK_SCANF1N (42, "42", "%w8d%w8n");
  94     CHECK_SCANF1 (-43, "-43", "%w8d");
  95     CHECK_SCANF1 (42, "42", "%w8i");
  96     CHECK_SCANF1 (-43, "-43", "%w8i");
  97     CHECK_SCANF1 (123, "0b1111011", "%w8i");
  98     CHECK_SCANF1 (127, "0x7f", "%w8i");
  99     CHECK_SCANF1 (-19, "-023", "%w8i");
 100   }
 101   {
 102     uint_least8_t var;
 103     int_least8_t n;
 104     CHECK_SCANF1 (123, "1111011", "%w8b");
 105     CHECK_SCANF1 (19, "023", "%w8o");
 106     CHECK_SCANF1 (50, "50", "%w8u");
 107     CHECK_SCANF1 (65, "41", "%w8x");
 108     CHECK_SCANF1N (65, "41", "%w8x%w8n");
 109     CHECK_SCANF1 (66, "42", "%w8X");
 110   }
 111 }
 112
 113 static void
 114 test_wf8 (void)
 115 {
 116   {
 117     int_fast8_t var, n;
 118     CHECK_SCANF1 (42, "42", "%wf8d");
 119     CHECK_SCANF1N (42, "42", "%wf8d%wf8n");
 120     CHECK_SCANF1 (-43, "-43", "%wf8d");
 121     CHECK_SCANF1 (42, "42", "%wf8i");
 122     CHECK_SCANF1 (-43, "-43", "%wf8i");
 123     CHECK_SCANF1 (123, "0b1111011", "%wf8i");
 124     CHECK_SCANF1 (127, "0x7f", "%wf8i");
 125     CHECK_SCANF1 (-19, "-023", "%wf8i");
 126   }
 127   {
 128     uint_fast8_t var;
 129     int_fast8_t n;
 130     CHECK_SCANF1 (123, "1111011", "%wf8b");
 131     CHECK_SCANF1 (19, "023", "%wf8o");
 132     CHECK_SCANF1 (50, "50", "%wf8u");
 133     CHECK_SCANF1 (65, "41", "%wf8x");
 134     CHECK_SCANF1N (65, "41", "%wf8x%wf8n");
 135     CHECK_SCANF1 (66, "42", "%wf8X");
 136   }
 137 }
 138
 139 static void
 140 test_w16 (void)
 141 {
 142   {
 143     int16_t var, n;
 144     CHECK_SCANF1 (12345, "12345", "%w16d");
 145     CHECK_SCANF1N (23456, "23456", "%w16d%w16n");
 146     CHECK_SCANF1 (-10101, "-10101", "%w16d");
 147     CHECK_SCANF1 (30000, "30000", "%w16i");
 148     CHECK_SCANF1 (-19876, "-19876", "%w16i");
 149     CHECK_SCANF1 (16384, "0b100000000000000", "%w16i");
 150     CHECK_SCANF1 (32767, "0x7fff", "%w16i");
 151     CHECK_SCANF1 (-16383, "-037777", "%w16i");
 152   }
 153   {
 154     uint16_t var;
 155     int16_t n;
 156     CHECK_SCANF1 (32767, "111111111111111", "%w16b");
 157     CHECK_SCANF1 (4095, "07777", "%w16o");
 158     CHECK_SCANF1 (9999, "9999", "%w16u");
 159     CHECK_SCANF1 (23456, "5ba0", "%w16x");
 160     CHECK_SCANF1N (23456, "5ba0", "%w16x%w16n");
 161     CHECK_SCANF1 (23457, "5ba1", "%w16X");
 162   }
 163   {
 164     int_least16_t var, n;
 165     CHECK_SCANF1 (12345, "12345", "%w16d");
 166     CHECK_SCANF1N (23456, "23456", "%w16d%w16n");
 167     CHECK_SCANF1 (-10101, "-10101", "%w16d");
 168     CHECK_SCANF1 (30000, "30000", "%w16i");
 169     CHECK_SCANF1 (-19876, "-19876", "%w16i");
 170     CHECK_SCANF1 (16384, "0b100000000000000", "%w16i");
 171     CHECK_SCANF1 (32767, "0x7fff", "%w16i");
 172     CHECK_SCANF1 (-16383, "-037777", "%w16i");
 173   }
 174   {
 175     uint_least16_t var;
 176     int_least16_t n;
 177     CHECK_SCANF1 (32767, "111111111111111", "%w16b");
 178     CHECK_SCANF1 (4095, "07777", "%w16o");
 179     CHECK_SCANF1 (9999, "9999", "%w16u");
 180     CHECK_SCANF1 (23456, "5ba0", "%w16x");
 181     CHECK_SCANF1N (23456, "5ba0", "%w16x%w16n");
 182     CHECK_SCANF1 (23457, "5ba1", "%w16X");
 183   }
 184 }
 185
 186 static void
 187 test_wf16 (void)
 188 {
 189   {
 190     int_fast16_t var, n;
 191     CHECK_SCANF1 (12345, "12345", "%wf16d");
 192     CHECK_SCANF1N (23456, "23456", "%wf16d%wf16n");
 193     CHECK_SCANF1 (-10101, "-10101", "%wf16d");
 194     CHECK_SCANF1 (30000, "30000", "%wf16i");
 195     CHECK_SCANF1 (-19876, "-19876", "%wf16i");
 196     CHECK_SCANF1 (16384, "0b100000000000000", "%wf16i");
 197     CHECK_SCANF1 (32767, "0x7fff", "%wf16i");
 198     CHECK_SCANF1 (-16383, "-037777", "%wf16i");
 199   }
 200   {
 201     uint_fast16_t var;
 202     int_fast16_t n;
 203     CHECK_SCANF1 (32767, "111111111111111", "%wf16b");
 204     CHECK_SCANF1 (4095, "07777", "%wf16o");
 205     CHECK_SCANF1 (9999, "9999", "%wf16u");
 206     CHECK_SCANF1 (23456, "5ba0", "%wf16x");
 207     CHECK_SCANF1N (23456, "5ba0", "%wf16x%wf16n");
 208     CHECK_SCANF1 (23457, "5ba1", "%wf16X");
 209   }
 210 #if INT_FAST16_MAX >= INT32_MAX
 211   {
 212     int_fast16_t var, n;
 213     CHECK_SCANF1 (1234567, "1234567", "%wf16d");
 214     CHECK_SCANF1N (2345678, "2345678", "%wf16d%wf16n");
 215     CHECK_SCANF1 (-1010101, "-1010101", "%wf16d");
 216     CHECK_SCANF1 (3000000, "3000000", "%wf16i");
 217     CHECK_SCANF1 (-98765432, "-98765432", "%wf16i");
 218     CHECK_SCANF1 (1048576, "0b100000000000000000000", "%wf16i");
 219     CHECK_SCANF1 (1048575, "0xfffff", "%wf16i");
 220     CHECK_SCANF1 (-1048575, "-03777777", "%wf16i");
 221   }
 222   {
 223     uint_fast16_t var;
 224     int_fast16_t n;
 225     CHECK_SCANF1 (1234567, "100101101011010000111", "%wf16b");
 226     CHECK_SCANF1 (1048575, "03777777", "%wf16o");
 227     CHECK_SCANF1 (999999, "999999", "%wf16u");
 228     CHECK_SCANF1 (987654, "f1206", "%wf16x");
 229     CHECK_SCANF1N (987654, "f1206", "%wf16x%wf16n");
 230     CHECK_SCANF1 (987655, "f1207", "%wf16X");
 231   }
 232 #endif
 233 #if INT_FAST16_MAX >= INT64_MAX
 234   {
 235     int_fast16_t var, n;
 236     CHECK_SCANF1 (123456789012LL, "123456789012", "%wf16d");
 237     CHECK_SCANF1N (234567890123LL, "234567890123", "%wf16d%wf16n");
 238     CHECK_SCANF1 (-10101010101LL, "-10101010101", "%wf16d");
 239     CHECK_SCANF1 (3000000000000000LL, "3000000000000000", "%wf16i");
 240     CHECK_SCANF1 (-9876543210LL, "-9876543210", "%wf16i");
 241     CHECK_SCANF1 (1LL << 40, "0b10000000000000000000000000000000000000000",
 242                   "%wf16i");
 243     CHECK_SCANF1 (1LL << 41, "0x20000000000", "%wf16i");
 244     CHECK_SCANF1 (-(1LL << 42), "-0100000000000000", "%wf16i");
 245   }
 246   {
 247     uint_fast16_t var;
 248     int_fast16_t n;
 249     CHECK_SCANF1 (123456789012ULL, "1110010111110100110010001101000010100",
 250                   "%wf16b");
 251     CHECK_SCANF1 (1ULL << 40, "20000000000000", "%wf16o");
 252     CHECK_SCANF1 (999999999999ULL, "999999999999", "%wf16u");
 253     CHECK_SCANF1 (9876543210ULL, "24cb016ea", "%wf16x");
 254     CHECK_SCANF1N (9876543210ULL, "24cb016ea", "%wf16x%wf16n");
 255     CHECK_SCANF1 (9876543211ULL, "24cb016eb", "%wf16X");
 256   }
 257 #endif
 258 }
 259
 260 static void
 261 test_w32 (void)
 262 {
 263   {
 264     int32_t var, n;
 265     CHECK_SCANF1 (1234567, "1234567", "%w32d");
 266     CHECK_SCANF1N (2345678, "2345678", "%w32d%w32n");
 267     CHECK_SCANF1 (-1010101, "-1010101", "%w32d");
 268     CHECK_SCANF1 (3000000, "3000000", "%w32i");
 269     CHECK_SCANF1 (-98765432, "-98765432", "%w32i");
 270     CHECK_SCANF1 (1048576, "0b100000000000000000000", "%w32i");
 271     CHECK_SCANF1 (1048575, "0xfffff", "%w32i");
 272     CHECK_SCANF1 (-1048575, "-03777777", "%w32i");
 273   }
 274   {
 275     uint32_t var;
 276     int32_t n;
 277     CHECK_SCANF1 (1234567, "100101101011010000111", "%w32b");
 278     CHECK_SCANF1 (1048575, "03777777", "%w32o");
 279     CHECK_SCANF1 (999999, "999999", "%w32u");
 280     CHECK_SCANF1 (987654, "f1206", "%w32x");
 281     CHECK_SCANF1N (987654, "f1206", "%w32x%w32n");
 282     CHECK_SCANF1 (987655, "f1207", "%w32X");
 283   }
 284   {
 285     int_least32_t var, n;
 286     CHECK_SCANF1 (1234567, "1234567", "%w32d");
 287     CHECK_SCANF1N (2345678, "2345678", "%w32d%w32n");
 288     CHECK_SCANF1 (-1010101, "-1010101", "%w32d");
 289     CHECK_SCANF1 (3000000, "3000000", "%w32i");
 290     CHECK_SCANF1 (-98765432, "-98765432", "%w32i");
 291     CHECK_SCANF1 (1048576, "0b100000000000000000000", "%w32i");
 292     CHECK_SCANF1 (1048575, "0xfffff", "%w32i");
 293     CHECK_SCANF1 (-1048575, "-03777777", "%w32i");
 294   }
 295   {
 296     uint_least32_t var;
 297     int_least32_t n;
 298     CHECK_SCANF1 (1234567, "100101101011010000111", "%w32b");
 299     CHECK_SCANF1 (1048575, "03777777", "%w32o");
 300     CHECK_SCANF1 (999999, "999999", "%w32u");
 301     CHECK_SCANF1 (987654, "f1206", "%w32x");
 302     CHECK_SCANF1N (987654, "f1206", "%w32x%w32n");
 303     CHECK_SCANF1 (987655, "f1207", "%w32X");
 304   }
 305 }
 306
 307 static void
 308 test_wf32 (void)
 309 {
 310   {
 311     int_fast32_t var, n;
 312     CHECK_SCANF1 (1234567, "1234567", "%wf32d");
 313     CHECK_SCANF1N (2345678, "2345678", "%wf32d%wf32n");
 314     CHECK_SCANF1 (-1010101, "-1010101", "%wf32d");
 315     CHECK_SCANF1 (3000000, "3000000", "%wf32i");
 316     CHECK_SCANF1 (-98765432, "-98765432", "%wf32i");
 317     CHECK_SCANF1 (1048576, "0b100000000000000000000", "%wf32i");
 318     CHECK_SCANF1 (1048575, "0xfffff", "%wf32i");
 319     CHECK_SCANF1 (-1048575, "-03777777", "%wf32i");
 320   }
 321   {
 322     uint_fast32_t var;
 323     int_fast32_t n;
 324     CHECK_SCANF1 (1234567, "100101101011010000111", "%wf32b");
 325     CHECK_SCANF1 (1048575, "03777777", "%wf32o");
 326     CHECK_SCANF1 (999999, "999999", "%wf32u");
 327     CHECK_SCANF1 (987654, "f1206", "%wf32x");
 328     CHECK_SCANF1N (987654, "f1206", "%wf32x%wf32n");
 329     CHECK_SCANF1 (987655, "f1207", "%wf32X");
 330   }
 331 #if INT_FAST32_MAX >= INT64_MAX
 332   {
 333     int_fast32_t var, n;
 334     CHECK_SCANF1 (123456789012LL, "123456789012", "%wf32d");
 335     CHECK_SCANF1N (234567890123LL, "234567890123", "%wf32d%wf32n");
 336     CHECK_SCANF1 (-10101010101LL, "-10101010101", "%wf32d");
 337     CHECK_SCANF1 (3000000000000000LL, "3000000000000000", "%wf32i");
 338     CHECK_SCANF1 (-9876543210LL, "-9876543210", "%wf32i");
 339     CHECK_SCANF1 (1LL << 40, "0b10000000000000000000000000000000000000000",
 340                   "%wf32i");
 341     CHECK_SCANF1 (1LL << 41, "0x20000000000", "%wf32i");
 342     CHECK_SCANF1 (-(1LL << 42), "-0100000000000000", "%wf32i");
 343   }
 344   {
 345     uint_fast32_t var;
 346     int_fast32_t n;
 347     CHECK_SCANF1 (123456789012ULL, "1110010111110100110010001101000010100",
 348                   "%wf32b");
 349     CHECK_SCANF1 (1ULL << 40, "20000000000000", "%wf32o");
 350     CHECK_SCANF1 (999999999999ULL, "999999999999", "%wf32u");
 351     CHECK_SCANF1 (9876543210ULL, "24cb016ea", "%wf32x");
 352     CHECK_SCANF1N (9876543210ULL, "24cb016ea", "%wf32x%wf32n");
 353     CHECK_SCANF1 (9876543211ULL, "24cb016eb", "%wf32X");
 354   }
 355 #endif
 356 }
 357
 358 static void
 359 test_w64 (void)
 360 {
 361   {
 362     int64_t var, n;
 363     CHECK_SCANF1 (123456789012LL, "123456789012", "%w64d");
 364     CHECK_SCANF1N (234567890123LL, "234567890123", "%w64d%w64n");
 365     CHECK_SCANF1 (-10101010101LL, "-10101010101", "%w64d");
 366     CHECK_SCANF1 (3000000000000000LL, "3000000000000000", "%w64i");
 367     CHECK_SCANF1 (-9876543210LL, "-9876543210", "%w64i");
 368     CHECK_SCANF1 (1LL << 40, "0b10000000000000000000000000000000000000000",
 369                   "%w64i");
 370     CHECK_SCANF1 (1LL << 41, "0x20000000000", "%w64i");
 371     CHECK_SCANF1 (-(1LL << 42), "-0100000000000000", "%w64i");
 372   }
 373   {
 374     uint64_t var;
 375     int64_t n;
 376     CHECK_SCANF1 (123456789012ULL, "1110010111110100110010001101000010100",
 377                   "%w64b");
 378     CHECK_SCANF1 (1ULL << 40, "20000000000000", "%w64o");
 379     CHECK_SCANF1 (999999999999ULL, "999999999999", "%w64u");
 380     CHECK_SCANF1 (9876543210ULL, "24cb016ea", "%w64x");
 381     CHECK_SCANF1N (9876543210ULL, "24cb016ea", "%w64x%w64n");
 382     CHECK_SCANF1 (9876543211ULL, "24cb016eb", "%w64X");
 383   }
 384   {
 385     int_least64_t var, n;
 386     CHECK_SCANF1 (123456789012LL, "123456789012", "%w64d");
 387     CHECK_SCANF1N (234567890123LL, "234567890123", "%w64d%w64n");
 388     CHECK_SCANF1 (-10101010101LL, "-10101010101", "%w64d");
 389     CHECK_SCANF1 (3000000000000000LL, "3000000000000000", "%w64i");
 390     CHECK_SCANF1 (-9876543210LL, "-9876543210", "%w64i");
 391     CHECK_SCANF1 (1LL << 40, "0b10000000000000000000000000000000000000000",
 392                   "%w64i");
 393     CHECK_SCANF1 (1LL << 41, "0x20000000000", "%w64i");
 394     CHECK_SCANF1 (-(1LL << 42), "-0100000000000000", "%w64i");
 395   }
 396   {
 397     uint_least64_t var;
 398     int_least64_t n;
 399     CHECK_SCANF1 (123456789012ULL, "1110010111110100110010001101000010100",
 400                   "%w64b");
 401     CHECK_SCANF1 (1ULL << 40, "20000000000000", "%w64o");
 402     CHECK_SCANF1 (999999999999ULL, "999999999999", "%w64u");
 403     CHECK_SCANF1 (9876543210ULL, "24cb016ea", "%w64x");
 404     CHECK_SCANF1N (9876543210ULL, "24cb016ea", "%w64x%w64n");
 405     CHECK_SCANF1 (9876543211ULL, "24cb016eb", "%w64X");
 406   }
 407 }
 408
 409 static void
 410 test_wf64 (void)
 411 {
 412   {
 413     int_fast64_t var, n;
 414     CHECK_SCANF1 (123456789012LL, "123456789012", "%wf64d");
 415     CHECK_SCANF1N (234567890123LL, "234567890123", "%wf64d%wf64n");
 416     CHECK_SCANF1 (-10101010101LL, "-10101010101", "%wf64d");
 417     CHECK_SCANF1 (3000000000000000LL, "3000000000000000", "%wf64i");
 418     CHECK_SCANF1 (-9876543210LL, "-9876543210", "%wf64i");
 419     CHECK_SCANF1 (1LL << 40, "0b10000000000000000000000000000000000000000",
 420                   "%wf64i");
 421     CHECK_SCANF1 (1LL << 41, "0x20000000000", "%wf64i");
 422     CHECK_SCANF1 (-(1LL << 42), "-0100000000000000", "%wf64i");
 423   }
 424   {
 425     uint_fast64_t var;
 426     int_fast64_t n;
 427     CHECK_SCANF1 (123456789012ULL, "1110010111110100110010001101000010100",
 428                   "%wf64b");
 429     CHECK_SCANF1 (1ULL << 40, "20000000000000", "%wf64o");
 430     CHECK_SCANF1 (999999999999ULL, "999999999999", "%wf64u");
 431     CHECK_SCANF1 (9876543210ULL, "24cb016ea", "%wf64x");
 432     CHECK_SCANF1N (9876543210ULL, "24cb016ea", "%wf64x%wf64n");
 433     CHECK_SCANF1 (9876543211ULL, "24cb016eb", "%wf64X");
 434   }
 435 }
 436
 437 static int
 438 do_test (void)
 439 {
 440   int a, b;
 441   test_w8 ();
 442   test_wf8 ();
 443   test_w16 ();
 444   test_wf16 ();
 445   test_w32 ();
 446   test_wf32 ();
 447   test_w64 ();
 448   test_wf64 ();
 449   /* Bad N in %wN and %wfN are required to produce an error return (of
 450      the number of input items assigned) from scanf functions (and can
 451      also be seen to be invalid at compile time).  */
 452   DIAG_PUSH_NEEDS_COMMENT;
 453   DIAG_IGNORE_NEEDS_COMMENT (13, "-Wformat");
 454   DIAG_IGNORE_NEEDS_COMMENT (13, "-Wformat-extra-args");
 455   CHECK_SCANF_ERR (0, "1", "%w1d", &a);
 456   CHECK_SCANF_ERR (0, "1", "%w123d", &a);
 457   CHECK_SCANF_ERR (0, "1", "%w99999999999999999999d", &a);
 458   CHECK_SCANF_ERR (0, "1", "%wf1d", &a);
 459   CHECK_SCANF_ERR (0, "1", "%wf123d", &a);
 460   CHECK_SCANF_ERR (0, "1", "%wf99999999999999999999d", &a);
 461   CHECK_SCANF_ERR (1, "1 1", "%d %w1d", &a, &b);
 462   CHECK_SCANF_ERR (1, "1 1", "%d %w123d", &a, &b);
 463   CHECK_SCANF_ERR (1, "1 1", "%d %w99999999999999999999d", &a, &b);
 464   CHECK_SCANF_ERR (1, "1 1", "%d %wf1d", &a, &b);
 465   CHECK_SCANF_ERR (1, "1 1", "%d %wf123d", &a, &b);
 466   CHECK_SCANF_ERR (1, "1 1", "%d %wf99999999999999999999d", &a, &b);
 467   CHECK_SCANF_ERR (0, "1", "%1$w1d", &a);
 468   CHECK_SCANF_ERR (0, "1", "%1$w123d", &a);
 469   CHECK_SCANF_ERR (0, "1", "%1$w99999999999999999999d", &a);
 470   CHECK_SCANF_ERR (0, "1", "%1$wf1d", &a);
 471   CHECK_SCANF_ERR (0, "1", "%1$wf123d", &a);
 472   CHECK_SCANF_ERR (0, "1", "%1$wf99999999999999999999d", &a);
 473   DIAG_POP_NEEDS_COMMENT;
 474   return 0;
 475 }
 476
 477 DIAG_POP_NEEDS_COMMENT;
 478
 479 #include <support/test-driver.c>