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> |
480 | |