ReactOS 0.4.15-dev-5896-g3f5bcf5
printf.c
Go to the documentation of this file.
1/*
2 * Conformance tests for *printf functions.
3 *
4 * Copyright 2002 Uwe Bonnes
5 * Copyright 2004 Aneurin Price
6 * Copyright 2005 Mike McCormack
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23/* With Visual Studio >= 2005, swprintf() takes an extra parameter unless
24 * the following macro is defined.
25 */
26#ifndef _CRT_NON_CONFORMING_SWPRINTFS
27#define _CRT_NON_CONFORMING_SWPRINTFS
28#endif
29
30#include <stdio.h>
31#include <errno.h>
32#include <math.h>
33#include <locale.h>
34
35#include "windef.h"
36#include "winbase.h"
37#include "winnls.h"
38
39#include "wine/test.h"
40
41#ifndef __REACTOS__
42
43static inline float __port_infinity(void)
44{
45 static const unsigned __inf_bytes = 0x7f800000;
46 return *(const float *)&__inf_bytes;
47}
48#define INFINITY __port_infinity()
49
50static inline float __port_nan(void)
51{
52 static const unsigned __nan_bytes = 0x7fc00000;
53 return *(const float *)&__nan_bytes;
54}
55#define NAN __port_nan()
56
57#endif
58
59static inline float __port_ind(void)
60{
61 static const unsigned __ind_bytes = 0xffc00000;
62 return *(const float *)&__ind_bytes;
63}
64#define IND __port_ind()
65
66static int (__cdecl *p__vscprintf)(const char *format, __ms_va_list valist);
67static int (__cdecl *p__vscwprintf)(const wchar_t *format, __ms_va_list valist);
68static int (__cdecl *p__vsnwprintf_s)(wchar_t *str, size_t sizeOfBuffer,
69 size_t count, const wchar_t *format,
70 __ms_va_list valist);
71static int (__cdecl *p__ecvt_s)(char *buffer, size_t length, double number,
72 int ndigits, int *decpt, int *sign);
73static int (__cdecl *p__fcvt_s)(char *buffer, size_t length, double number,
74 int ndigits, int *decpt, int *sign);
75static unsigned int (__cdecl *p__get_output_format)(void);
76static unsigned int (__cdecl *p__set_output_format)(unsigned int);
77static int (WINAPIV *p_sprintf)(char*, ...);
78static int (__cdecl *p__vsprintf_p)(char*, size_t, const char*, __ms_va_list);
79static int (__cdecl *p_vswprintf)(wchar_t *str, const wchar_t *format, __ms_va_list valist);
80static int (__cdecl *p__vswprintf)(wchar_t *str, const wchar_t *format, __ms_va_list valist);
81static int (__cdecl *p__vswprintf_l)(wchar_t *str, const wchar_t *format,
82 void *locale, __ms_va_list valist);
83static int (__cdecl *p__vswprintf_c)(wchar_t *str, size_t size, const wchar_t *format,
84 __ms_va_list valist);
85static int (__cdecl *p__vswprintf_c_l)(wchar_t *str, size_t size, const wchar_t *format,
86 void *locale, __ms_va_list valist);
87static int (__cdecl *p__vswprintf_p_l)(wchar_t *str, size_t size, const wchar_t *format,
88 void *locale, __ms_va_list valist);
89
90static void init( void )
91{
92 HMODULE hmod = GetModuleHandleA("msvcrt.dll");
93
94 p_sprintf = (void *)GetProcAddress(hmod, "sprintf");
95 p__vscprintf = (void *)GetProcAddress(hmod, "_vscprintf");
96 p__vscwprintf = (void *)GetProcAddress(hmod, "_vscwprintf");
97 p__vsnwprintf_s = (void *)GetProcAddress(hmod, "_vsnwprintf_s");
98 p__ecvt_s = (void *)GetProcAddress(hmod, "_ecvt_s");
99 p__fcvt_s = (void *)GetProcAddress(hmod, "_fcvt_s");
100 p__get_output_format = (void *)GetProcAddress(hmod, "_get_output_format");
101 p__set_output_format = (void *)GetProcAddress(hmod, "_set_output_format");
102 p__vsprintf_p = (void*)GetProcAddress(hmod, "_vsprintf_p");
103 p_vswprintf = (void*)GetProcAddress(hmod, "vswprintf");
104 p__vswprintf = (void*)GetProcAddress(hmod, "_vswprintf");
105 p__vswprintf_l = (void*)GetProcAddress(hmod, "_vswprintf_l");
106 p__vswprintf_c = (void*)GetProcAddress(hmod, "_vswprintf_c");
107 p__vswprintf_c_l = (void*)GetProcAddress(hmod, "_vswprintf_c_l");
108 p__vswprintf_p_l = (void*)GetProcAddress(hmod, "_vswprintf_p_l");
109}
110
111static void test_sprintf( void )
112{
113 char buffer[100];
114 const char *format;
115 double pnumber=789456123;
116 int x, r;
117 WCHAR wide[] = { 'w','i','d','e',0};
118 WCHAR buf_w[2];
119
120 format = "%+#23.15e";
121 r = p_sprintf(buffer,format,pnumber);
122 ok(!strcmp(buffer,"+7.894561230000000e+008"),"+#23.15e failed: '%s'\n", buffer);
123 ok( r==23, "return count wrong\n");
124
125 format = "%-#23.15e";
126 r = p_sprintf(buffer,format,pnumber);
127 ok(!strcmp(buffer,"7.894561230000000e+008 "),"-#23.15e failed: '%s'\n", buffer);
128 ok( r==23, "return count wrong\n");
129
130 format = "%#23.15e";
131 r = p_sprintf(buffer,format,pnumber);
132 ok(!strcmp(buffer," 7.894561230000000e+008"),"#23.15e failed: '%s'\n", buffer);
133 ok( r==23, "return count wrong\n");
134
135 format = "%#1.1g";
136 r = p_sprintf(buffer,format,pnumber);
137 ok(!strcmp(buffer,"8.e+008"),"#1.1g failed: '%s'\n", buffer);
138 ok( r==7, "return count wrong\n");
139
140 format = "%I64d";
141 r = p_sprintf(buffer,format,((ULONGLONG)0xffffffff)*0xffffffff);
142 ok(!strcmp(buffer,"-8589934591"),"Problem with long long\n");
143 ok( r==11, "return count wrong\n");
144
145 format = "%+8I64d";
146 r = p_sprintf(buffer,format,(LONGLONG)100);
147 ok(!strcmp(buffer," +100") && r==8,"+8I64d failed: '%s'\n", buffer);
148
149 format = "%+.8I64d";
150 r = p_sprintf(buffer,format,(LONGLONG)100);
151 ok(!strcmp(buffer,"+00000100") && r==9,"+.8I64d failed: '%s'\n", buffer);
152
153 format = "%+10.8I64d";
154 r = p_sprintf(buffer,format,(LONGLONG)100);
155 ok(!strcmp(buffer," +00000100") && r==10,"+10.8I64d failed: '%s'\n", buffer);
156 format = "%_1I64d";
157 r = p_sprintf(buffer,format,(LONGLONG)100);
158 ok(!strcmp(buffer,"_1I64d") && r==6,"_1I64d failed\n");
159
160 format = "%-1.5I64d";
161 r = p_sprintf(buffer,format,(LONGLONG)-100);
162 ok(!strcmp(buffer,"-00100") && r==6,"-1.5I64d failed: '%s'\n", buffer);
163
164 format = "%5I64d";
165 r = p_sprintf(buffer,format,(LONGLONG)100);
166 ok(!strcmp(buffer," 100") && r==5,"5I64d failed: '%s'\n", buffer);
167
168 format = "%5I64d";
169 r = p_sprintf(buffer,format,(LONGLONG)-100);
170 ok(!strcmp(buffer," -100") && r==5,"5I64d failed: '%s'\n", buffer);
171
172 format = "%-5I64d";
173 r = p_sprintf(buffer,format,(LONGLONG)100);
174 ok(!strcmp(buffer,"100 ") && r==5,"-5I64d failed: '%s'\n", buffer);
175
176 format = "%-5I64d";
177 r = p_sprintf(buffer,format,(LONGLONG)-100);
178 ok(!strcmp(buffer,"-100 ") && r==5,"-5I64d failed: '%s'\n", buffer);
179
180 format = "%-.5I64d";
181 r = p_sprintf(buffer,format,(LONGLONG)100);
182 ok(!strcmp(buffer,"00100") && r==5,"-.5I64d failed: '%s'\n", buffer);
183
184 format = "%-.5I64d";
185 r = p_sprintf(buffer,format,(LONGLONG)-100);
186 ok(!strcmp(buffer,"-00100") && r==6,"-.5I64d failed: '%s'\n", buffer);
187
188 format = "%-8.5I64d";
189 r = p_sprintf(buffer,format,(LONGLONG)100);
190 ok(!strcmp(buffer,"00100 ") && r==8,"-8.5I64d failed: '%s'\n", buffer);
191
192 format = "%-8.5I64d";
193 r = p_sprintf(buffer,format,(LONGLONG)-100);
194 ok(!strcmp(buffer,"-00100 ") && r==8,"-8.5I64d failed: '%s'\n", buffer);
195
196 format = "%05I64d";
197 r = p_sprintf(buffer,format,(LONGLONG)100);
198 ok(!strcmp(buffer,"00100") && r==5,"05I64d failed: '%s'\n", buffer);
199
200 format = "%05I64d";
201 r = p_sprintf(buffer,format,(LONGLONG)-100);
202 ok(!strcmp(buffer,"-0100") && r==5,"05I64d failed: '%s'\n", buffer);
203
204 format = "% I64d";
205 r = p_sprintf(buffer,format,(LONGLONG)100);
206 ok(!strcmp(buffer," 100") && r==4,"' I64d' failed: '%s'\n", buffer);
207
208 format = "% I64d";
209 r = p_sprintf(buffer,format,(LONGLONG)-100);
210 ok(!strcmp(buffer,"-100") && r==4,"' I64d' failed: '%s'\n", buffer);
211
212 format = "% 5I64d";
213 r = p_sprintf(buffer,format,(LONGLONG)100);
214 ok(!strcmp(buffer," 100") && r==5,"' 5I64d' failed: '%s'\n", buffer);
215
216 format = "% 5I64d";
217 r = p_sprintf(buffer,format,(LONGLONG)-100);
218 ok(!strcmp(buffer," -100") && r==5,"' 5I64d' failed: '%s'\n", buffer);
219
220 format = "% .5I64d";
221 r = p_sprintf(buffer,format,(LONGLONG)100);
222 ok(!strcmp(buffer," 00100") && r==6,"' .5I64d' failed: '%s'\n", buffer);
223
224 format = "% .5I64d";
225 r = p_sprintf(buffer,format,(LONGLONG)-100);
226 ok(!strcmp(buffer,"-00100") && r==6,"' .5I64d' failed: '%s'\n", buffer);
227
228 format = "% 8.5I64d";
229 r = p_sprintf(buffer,format,(LONGLONG)100);
230 ok(!strcmp(buffer," 00100") && r==8,"' 8.5I64d' failed: '%s'\n", buffer);
231
232 format = "% 8.5I64d";
233 r = p_sprintf(buffer,format,(LONGLONG)-100);
234 ok(!strcmp(buffer," -00100") && r==8,"' 8.5I64d' failed: '%s'\n", buffer);
235
236 format = "%.0I64d";
237 r = p_sprintf(buffer,format,(LONGLONG)0);
238 ok(r==0,".0I64d failed: '%s'\n", buffer);
239
240 format = "%#+21.18I64x";
241 r = p_sprintf(buffer,format,(LONGLONG)-100);
242 ok(!strcmp(buffer," 0x00ffffffffffffff9c") && r==21,"#+21.18I64x failed: '%s'\n", buffer);
243
244 format = "%#.25I64o";
245 r = p_sprintf(buffer,format,(LONGLONG)-100);
246 ok(!strcmp(buffer,"0001777777777777777777634") && r==25,"#.25I64o failed: '%s'\n", buffer);
247
248 format = "%#+24.20I64o";
249 r = p_sprintf(buffer,format,(LONGLONG)-100);
250 ok(!strcmp(buffer," 01777777777777777777634") && r==24,"#+24.20I64o failed: '%s'\n", buffer);
251
252 format = "%#+18.21I64X";
253 r = p_sprintf(buffer,format,(LONGLONG)-100);
254 ok(!strcmp(buffer,"0X00000FFFFFFFFFFFFFF9C") && r==23,"#+18.21I64X failed: '%s '\n", buffer);
255
256 format = "%#+20.24I64o";
257 r = p_sprintf(buffer,format,(LONGLONG)-100);
258 ok(!strcmp(buffer,"001777777777777777777634") && r==24,"#+20.24I64o failed: '%s'\n", buffer);
259
260 format = "%#+25.22I64u";
261 r = p_sprintf(buffer,format,(LONGLONG)-1);
262 ok(!strcmp(buffer," 0018446744073709551615") && r==25,"#+25.22I64u conversion failed: '%s'\n", buffer);
263
264 format = "%#+25.22I64u";
265 r = p_sprintf(buffer,format,(LONGLONG)-1);
266 ok(!strcmp(buffer," 0018446744073709551615") && r==25,"#+25.22I64u failed: '%s'\n", buffer);
267
268 format = "%#+30.25I64u";
269 r = p_sprintf(buffer,format,(LONGLONG)-1);
270 ok(!strcmp(buffer," 0000018446744073709551615") && r==30,"#+30.25I64u failed: '%s'\n", buffer);
271
272 format = "%+#25.22I64d";
273 r = p_sprintf(buffer,format,(LONGLONG)-1);
274 ok(!strcmp(buffer," -0000000000000000000001") && r==25,"+#25.22I64d failed: '%s'\n", buffer);
275
276 format = "%#-8.5I64o";
277 r = p_sprintf(buffer,format,(LONGLONG)100);
278 ok(!strcmp(buffer,"00144 ") && r==8,"-8.5I64o failed: '%s'\n", buffer);
279
280 format = "%#-+ 08.5I64d";
281 r = p_sprintf(buffer,format,(LONGLONG)100);
282 ok(!strcmp(buffer,"+00100 ") && r==8,"'#-+ 08.5I64d failed: '%s'\n", buffer);
283
284 format = "%#-+ 08.5I64d";
285 r = p_sprintf(buffer,format,(LONGLONG)100);
286 ok(!strcmp(buffer,"+00100 ") && r==8,"#-+ 08.5I64d failed: '%s'\n", buffer);
287
288 format = "%.80I64d";
289 r = p_sprintf(buffer,format,(LONGLONG)1);
290 ok(r==80,"%s format failed\n", format);
291
292 format = "% .80I64d";
293 r = p_sprintf(buffer,format,(LONGLONG)1);
294 ok(r==81,"%s format failed\n", format);
295
296 format = "% .80d";
297 r = p_sprintf(buffer,format,1);
298 ok(r==81,"%s format failed\n", format);
299
300 format = "%lld";
301 r = p_sprintf(buffer,format,((ULONGLONG)0xffffffff)*0xffffffff);
302 ok( r == 1 || r == 11, "return count wrong %d\n", r);
303 if (r == 11) /* %ll works on Vista */
304 ok(!strcmp(buffer, "-8589934591"), "Problem with \"ll\" interpretation '%s'\n", buffer);
305 else
306 ok(!strcmp(buffer, "1"), "Problem with \"ll\" interpretation '%s'\n", buffer);
307
308 format = "%I";
309 r = p_sprintf(buffer,format,1);
310 ok(!strcmp(buffer, "I"), "Problem with \"I\" interpretation\n");
311 ok( r==1, "return count wrong\n");
312
313 format = "%I0d";
314 r = p_sprintf(buffer,format,1);
315 ok(!strcmp(buffer,"I0d"),"I0d failed\n");
316 ok( r==3, "return count wrong\n");
317
318 format = "%I32d";
319 r = p_sprintf(buffer,format,1);
320 if (r == 1)
321 {
322 ok(!strcmp(buffer,"1"),"I32d failed, got '%s'\n",buffer);
323 }
324 else
325 {
326 /* Older versions don't grok I32 format */
327 ok(r == 4 && !strcmp(buffer,"I32d"),"I32d failed, got '%s',%d\n",buffer,r);
328 }
329
330 format = "%I64D";
331 r = p_sprintf(buffer,format,(LONGLONG)-1);
332 ok(!strcmp(buffer,"D"),"I64D failed: %s\n",buffer);
333 ok( r==1, "return count wrong\n");
334
335 format = "%zx";
336 r = p_sprintf(buffer,format,1);
337 ok(!strcmp(buffer, "zx"), "Problem with \"z\" interpretation\n");
338 ok( r==2, "return count wrong\n");
339
340 format = "% d";
341 r = p_sprintf(buffer,format,1);
342 ok(!strcmp(buffer, " 1"),"Problem with sign place-holder: '%s'\n",buffer);
343 ok( r==2, "return count wrong\n");
344
345 format = "%+ d";
346 r = p_sprintf(buffer,format,1);
347 ok(!strcmp(buffer, "+1"),"Problem with sign flags: '%s'\n",buffer);
348 ok( r==2, "return count wrong\n");
349
350 format = "%S";
351 r = p_sprintf(buffer,format,wide);
352 ok(!strcmp(buffer,"wide"),"Problem with wide string format\n");
353 ok( r==4, "return count wrong\n");
354
355 format = "%04c";
356 r = p_sprintf(buffer,format,'1');
357 ok(!strcmp(buffer,"0001"),"Character not zero-prefixed \"%s\"\n",buffer);
358 ok( r==4, "return count wrong\n");
359
360 format = "%-04c";
361 r = p_sprintf(buffer,format,'1');
362 ok(!strcmp(buffer,"1 "),"Character zero-padded and/or not left-adjusted \"%s\"\n",buffer);
363 ok( r==4, "return count wrong\n");
364
365 format = "%#012x";
366 r = p_sprintf(buffer,format,1);
367 ok(!strcmp(buffer,"0x0000000001"),"Hexadecimal zero-padded \"%s\"\n",buffer);
368 ok( r==12, "return count wrong\n");
369
370 r = p_sprintf(buffer,format,0);
371 ok(!strcmp(buffer,"000000000000"),"Hexadecimal zero-padded \"%s\"\n",buffer);
372 ok( r==12, "return count wrong\n");
373
374 format = "%#04.8x";
375 r = p_sprintf(buffer,format,1);
376 ok(!strcmp(buffer,"0x00000001"), "Hexadecimal zero-padded precision \"%s\"\n",buffer);
377 ok( r==10, "return count wrong\n");
378
379 r = p_sprintf(buffer,format,0);
380 ok(!strcmp(buffer,"00000000"), "Hexadecimal zero-padded precision \"%s\"\n",buffer);
381 ok( r==8, "return count wrong\n");
382
383 format = "%#-08.2x";
384 r = p_sprintf(buffer,format,1);
385 ok(!strcmp(buffer,"0x01 "), "Hexadecimal zero-padded not left-adjusted \"%s\"\n",buffer);
386 ok( r==8, "return count wrong\n");
387
388 r = p_sprintf(buffer,format,0);
389 ok(!strcmp(buffer,"00 "), "Hexadecimal zero-padded not left-adjusted \"%s\"\n",buffer);
390 ok( r==8, "return count wrong\n");
391
392 format = "%#.0x";
393 r = p_sprintf(buffer,format,1);
394 ok(!strcmp(buffer,"0x1"), "Hexadecimal zero-padded zero-precision \"%s\"\n",buffer);
395 ok( r==3, "return count wrong\n");
396
397 r = p_sprintf(buffer,format,0);
398 ok(!strcmp(buffer,""), "Hexadecimal zero-padded zero-precision \"%s\"\n",buffer);
399 ok( r==0, "return count wrong\n");
400
401 format = "%#08o";
402 r = p_sprintf(buffer,format,1);
403 ok(!strcmp(buffer,"00000001"), "Octal zero-padded \"%s\"\n",buffer);
404 ok( r==8, "return count wrong\n");
405
406 format = "%#o";
407 r = p_sprintf(buffer,format,1);
408 ok(!strcmp(buffer,"01"), "Octal zero-padded \"%s\"\n",buffer);
409 ok( r==2, "return count wrong\n");
410
411 r = p_sprintf(buffer,format,0);
412 ok(!strcmp(buffer,"0"), "Octal zero-padded \"%s\"\n",buffer);
413 ok( r==1, "return count wrong\n");
414
415 if (sizeof(void *) == 8)
416 {
417 format = "%p";
418 r = p_sprintf(buffer,format,(void *)57);
419 ok(!strcmp(buffer,"0000000000000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
420 ok( r==16, "return count wrong\n");
421
422 format = "%#020p";
423 r = p_sprintf(buffer,format,(void *)57);
424 ok(!strcmp(buffer," 0X0000000000000039"),"Pointer formatted incorrectly\n");
425 ok( r==20, "return count wrong\n");
426
427 format = "%Fp";
428 r = p_sprintf(buffer,format,(void *)57);
429 ok(!strcmp(buffer,"0000000000000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
430 ok( r==16, "return count wrong\n");
431
432 format = "%Np";
433 r = p_sprintf(buffer,format,(void *)57);
434 ok(!strcmp(buffer,"0000000000000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
435 ok( r==16, "return count wrong\n");
436
437 format = "%#-020p";
438 r = p_sprintf(buffer,format,(void *)57);
439 ok(!strcmp(buffer,"0X0000000000000039 "),"Pointer formatted incorrectly\n");
440 ok( r==20, "return count wrong\n");
441
442 format = "%Ix %d";
443 r = p_sprintf(buffer,format,(size_t)0x12345678123456,1);
444 ok(!strcmp(buffer,"12345678123456 1"),"buffer = %s\n",buffer);
445 ok( r==16, "return count wrong\n");
446 }
447 else
448 {
449 format = "%p";
450 r = p_sprintf(buffer,format,(void *)57);
451 ok(!strcmp(buffer,"00000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
452 ok( r==8, "return count wrong\n");
453
454 format = "%#012p";
455 r = p_sprintf(buffer,format,(void *)57);
456 ok(!strcmp(buffer," 0X00000039"),"Pointer formatted incorrectly\n");
457 ok( r==12, "return count wrong\n");
458
459 format = "%Fp";
460 r = p_sprintf(buffer,format,(void *)57);
461 ok(!strcmp(buffer,"00000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
462 ok( r==8, "return count wrong\n");
463
464 format = "%Np";
465 r = p_sprintf(buffer,format,(void *)57);
466 ok(!strcmp(buffer,"00000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
467 ok( r==8, "return count wrong\n");
468
469 format = "%#-012p";
470 r = p_sprintf(buffer,format,(void *)57);
471 ok(!strcmp(buffer,"0X00000039 "),"Pointer formatted incorrectly\n");
472 ok( r==12, "return count wrong\n");
473
474 format = "%Ix %d";
475 r = p_sprintf(buffer,format,0x123456,1);
476 ok(!strcmp(buffer,"123456 1"),"buffer = %s\n",buffer);
477 ok( r==8, "return count wrong\n");
478 }
479
480 format = "%04s";
481 r = p_sprintf(buffer,format,"foo");
482 ok(!strcmp(buffer,"0foo"),"String not zero-prefixed \"%s\"\n",buffer);
483 ok( r==4, "return count wrong\n");
484
485 format = "%.1s";
486 r = p_sprintf(buffer,format,"foo");
487 ok(!strcmp(buffer,"f"),"Precision ignored \"%s\"\n",buffer);
488 ok( r==1, "return count wrong\n");
489
490 format = "%.*s";
491 r = p_sprintf(buffer,format,1,"foo");
492 ok(!strcmp(buffer,"f"),"Precision ignored \"%s\"\n",buffer);
493 ok( r==1, "return count wrong\n");
494
495 format = "%*s";
496 r = p_sprintf(buffer,format,-5,"foo");
497 ok(!strcmp(buffer,"foo "),"Negative field width ignored \"%s\"\n",buffer);
498 ok( r==5, "return count wrong\n");
499
500 format = "hello";
501 r = p_sprintf(buffer, format);
502 ok(!strcmp(buffer,"hello"), "failed\n");
503 ok( r==5, "return count wrong\n");
504
505 format = "%ws";
506 r = p_sprintf(buffer, format, wide);
507 ok(!strcmp(buffer,"wide"), "failed\n");
508 ok( r==4, "return count wrong\n");
509
510 format = "%-10ws";
511 r = p_sprintf(buffer, format, wide );
512 ok(!strcmp(buffer,"wide "), "failed\n");
513 ok( r==10, "return count wrong\n");
514
515 format = "%10ws";
516 r = p_sprintf(buffer, format, wide );
517 ok(!strcmp(buffer," wide"), "failed\n");
518 ok( r==10, "return count wrong\n");
519
520 format = "%#+ -03whlls";
521 r = p_sprintf(buffer, format, wide );
522 ok(!strcmp(buffer,"wide"), "failed\n");
523 ok( r==4, "return count wrong\n");
524
525 format = "%w0s";
526 r = p_sprintf(buffer, format, wide );
527 ok(!strcmp(buffer,"0s"), "failed\n");
528 ok( r==2, "return count wrong\n");
529
530 format = "%w-s";
531 r = p_sprintf(buffer, format, wide );
532 ok(!strcmp(buffer,"-s"), "failed\n");
533 ok( r==2, "return count wrong\n");
534
535 format = "%ls";
536 r = p_sprintf(buffer, format, wide );
537 ok(!strcmp(buffer,"wide"), "failed\n");
538 ok( r==4, "return count wrong\n");
539
540 format = "%Ls";
541 r = p_sprintf(buffer, format, "not wide" );
542 ok(!strcmp(buffer,"not wide"), "failed\n");
543 ok( r==8, "return count wrong\n");
544
545 format = "%b";
546 r = p_sprintf(buffer, format);
547 ok(!strcmp(buffer,"b"), "failed\n");
548 ok( r==1, "return count wrong\n");
549
550 format = "%3c";
551 r = p_sprintf(buffer, format,'a');
552 ok(!strcmp(buffer," a"), "failed\n");
553 ok( r==3, "return count wrong\n");
554
555 format = "%3d";
556 r = p_sprintf(buffer, format,1234);
557 ok(!strcmp(buffer,"1234"), "failed\n");
558 ok( r==4, "return count wrong\n");
559
560 format = "%3h";
561 r = p_sprintf(buffer, format);
562 ok(!strcmp(buffer,""), "failed\n");
563 ok( r==0, "return count wrong\n");
564
565 format = "%j%k%m%q%r%t%v%y%z";
566 r = p_sprintf(buffer, format);
567 ok(!strcmp(buffer,"jkmqrtvyz"), "failed\n");
568 ok( r==9, "return count wrong\n");
569
570 format = "asdf%n";
571 x = 0;
572 r = p_sprintf(buffer, format, &x );
573 if (r == -1)
574 {
575 /* %n format is disabled by default on vista */
576 /* FIXME: should test with _set_printf_count_output */
577 ok(x == 0, "should not write to x: %d\n", x);
578 }
579 else
580 {
581 ok(x == 4, "should write to x: %d\n", x);
582 ok(!strcmp(buffer,"asdf"), "failed\n");
583 ok( r==4, "return count wrong: %d\n", r);
584 }
585
586 format = "%-1d";
587 r = p_sprintf(buffer, format,2);
588 ok(!strcmp(buffer,"2"), "failed\n");
589 ok( r==1, "return count wrong\n");
590
591 format = "%2.4f";
592 r = p_sprintf(buffer, format,8.6);
593 ok(!strcmp(buffer,"8.6000"), "failed\n");
594 ok( r==6, "return count wrong\n");
595
596 format = "%0f";
597 r = p_sprintf(buffer, format,0.6);
598 ok(!strcmp(buffer,"0.600000"), "failed\n");
599 ok( r==8, "return count wrong\n");
600
601 format = "%.0f";
602 r = p_sprintf(buffer, format,0.6);
603 ok(!strcmp(buffer,"1"), "failed\n");
604 ok( r==1, "return count wrong\n");
605
606 format = "%2.4e";
607 r = p_sprintf(buffer, format,8.6);
608 ok(!strcmp(buffer,"8.6000e+000"), "failed\n");
609 ok( r==11, "return count wrong\n");
610
611 format = "% 2.4e";
612 r = p_sprintf(buffer, format,8.6);
613 ok(!strcmp(buffer," 8.6000e+000"), "failed: %s\n", buffer);
614 ok( r==12, "return count wrong\n");
615
616 format = "% 014.4e";
617 r = p_sprintf(buffer, format,8.6);
618 ok(!strcmp(buffer," 008.6000e+000"), "failed: %s\n", buffer);
619 ok( r==14, "return count wrong\n");
620
621 format = "% 2.4e";
622 r = p_sprintf(buffer, format,-8.6);
623 ok(!strcmp(buffer,"-8.6000e+000"), "failed: %s\n", buffer);
624 ok( r==12, "return count wrong\n");
625
626 format = "%+2.4e";
627 r = p_sprintf(buffer, format,8.6);
628 ok(!strcmp(buffer,"+8.6000e+000"), "failed: %s\n", buffer);
629 ok( r==12, "return count wrong\n");
630
631 format = "%2.4g";
632 r = p_sprintf(buffer, format,8.6);
633 ok(!strcmp(buffer,"8.6"), "failed\n");
634 ok( r==3, "return count wrong\n");
635
636 format = "%-i";
637 r = p_sprintf(buffer, format,-1);
638 ok(!strcmp(buffer,"-1"), "failed\n");
639 ok( r==2, "return count wrong\n");
640
641 format = "%-i";
642 r = p_sprintf(buffer, format,1);
643 ok(!strcmp(buffer,"1"), "failed\n");
644 ok( r==1, "return count wrong\n");
645
646 format = "%+i";
647 r = p_sprintf(buffer, format,1);
648 ok(!strcmp(buffer,"+1"), "failed\n");
649 ok( r==2, "return count wrong\n");
650
651 format = "%o";
652 r = p_sprintf(buffer, format,10);
653 ok(!strcmp(buffer,"12"), "failed\n");
654 ok( r==2, "return count wrong\n");
655
656 format = "%p";
657 r = p_sprintf(buffer, format,0);
658 if (sizeof(void *) == 8)
659 {
660 ok(!strcmp(buffer,"0000000000000000"), "failed\n");
661 ok( r==16, "return count wrong\n");
662 }
663 else
664 {
665 ok(!strcmp(buffer,"00000000"), "failed\n");
666 ok( r==8, "return count wrong\n");
667 }
668
669 format = "%s";
670 r = p_sprintf(buffer, format,0);
671 ok(!strcmp(buffer,"(null)"), "failed\n");
672 ok( r==6, "return count wrong\n");
673
674 format = "%s";
675 r = p_sprintf(buffer, format,"%%%%");
676 ok(!strcmp(buffer,"%%%%"), "failed\n");
677 ok( r==4, "return count wrong\n");
678
679 format = "%u";
680 r = p_sprintf(buffer, format,-1);
681 ok(!strcmp(buffer,"4294967295"), "failed\n");
682 ok( r==10, "return count wrong\n");
683
684 format = "%w";
685 r = p_sprintf(buffer, format,-1);
686 ok(!strcmp(buffer,""), "failed\n");
687 ok( r==0, "return count wrong\n");
688
689 format = "%h";
690 r = p_sprintf(buffer, format,-1);
691 ok(!strcmp(buffer,""), "failed\n");
692 ok( r==0, "return count wrong\n");
693
694 format = "%z";
695 r = p_sprintf(buffer, format,-1);
696 ok(!strcmp(buffer,"z"), "failed\n");
697 ok( r==1, "return count wrong\n");
698
699 format = "%j";
700 r = p_sprintf(buffer, format,-1);
701 ok(!strcmp(buffer,"j"), "failed\n");
702 ok( r==1, "return count wrong\n");
703
704 format = "%F";
705 r = p_sprintf(buffer, format,-1);
706 ok(!strcmp(buffer,""), "failed\n");
707 ok( r==0, "return count wrong\n");
708
709 format = "%N";
710 r = p_sprintf(buffer, format,-1);
711 ok(!strcmp(buffer,""), "failed\n");
712 ok( r==0, "return count wrong\n");
713
714 format = "%H";
715 r = p_sprintf(buffer, format,-1);
716 ok(!strcmp(buffer,"H"), "failed\n");
717 ok( r==1, "return count wrong\n");
718
719 format = "x%cx";
720 r = p_sprintf(buffer, format, 0x100+'X');
721 ok(!strcmp(buffer,"xXx"), "failed\n");
722 ok( r==3, "return count wrong\n");
723
724 format = "%%0";
725 r = p_sprintf(buffer, format);
726 ok(!strcmp(buffer,"%0"), "failed: \"%s\"\n", buffer);
727 ok( r==2, "return count wrong\n");
728
729 format = "%hx";
730 r = p_sprintf(buffer, format, 0x12345);
731 ok(!strcmp(buffer,"2345"), "failed \"%s\"\n", buffer);
732
733 format = "%hhx";
734 r = p_sprintf(buffer, format, 0x123);
735 ok(!strcmp(buffer,"123"), "failed: \"%s\"\n", buffer);
736 r = p_sprintf(buffer, format, 0x12345);
737 ok(!strcmp(buffer,"2345"), "failed \"%s\"\n", buffer);
738
739 format = "%lf";
740 r = p_sprintf(buffer, format, IND);
741 ok(r==9, "r = %d\n", r);
742 ok(!strcmp(buffer, "-1.#IND00"), "failed: \"%s\"\n", buffer);
743 r = p_sprintf(buffer, format, NAN);
744 ok(r==8, "r = %d\n", r);
745 ok(!strcmp(buffer, "1.#QNAN0"), "failed: \"%s\"\n", buffer);
746 r = p_sprintf(buffer, format, INFINITY);
747 ok(r==8, "r = %d\n", r);
748 ok(!strcmp(buffer, "1.#INF00"), "failed: \"%s\"\n", buffer);
749
750 format = "%le";
751 r = p_sprintf(buffer, format, IND);
752 ok(r==14, "r = %d\n", r);
753 ok(!strcmp(buffer, "-1.#IND00e+000"), "failed: \"%s\"\n", buffer);
754 r = p_sprintf(buffer, format, NAN);
755 ok(r==13, "r = %d\n", r);
756 ok(!strcmp(buffer, "1.#QNAN0e+000"), "failed: \"%s\"\n", buffer);
757 r = p_sprintf(buffer, format, INFINITY);
758 ok(r==13, "r = %d\n", r);
759 ok(!strcmp(buffer, "1.#INF00e+000"), "failed: \"%s\"\n", buffer);
760
761 format = "%lg";
762 r = p_sprintf(buffer, format, IND);
763 ok(r==7, "r = %d\n", r);
764 ok(!strcmp(buffer, "-1.#IND"), "failed: \"%s\"\n", buffer);
765 r = p_sprintf(buffer, format, NAN);
766 ok(r==7, "r = %d\n", r);
767 ok(!strcmp(buffer, "1.#QNAN"), "failed: \"%s\"\n", buffer);
768 r = p_sprintf(buffer, format, INFINITY);
769 ok(r==6, "r = %d\n", r);
770 ok(!strcmp(buffer, "1.#INF"), "failed: \"%s\"\n", buffer);
771
772 format = "%010.2lf";
773 r = p_sprintf(buffer, format, IND);
774 ok(r==10, "r = %d\n", r);
775 ok(!strcmp(buffer, "-000001.#J"), "failed: \"%s\"\n", buffer);
776 r = p_sprintf(buffer, format, NAN);
777 ok(r==10, "r = %d\n", r);
778 ok(!strcmp(buffer, "0000001.#R"), "failed: \"%s\"\n", buffer);
779 r = p_sprintf(buffer, format, INFINITY);
780 ok(r==10, "r = %d\n", r);
781 ok(!strcmp(buffer, "0000001.#J"), "failed: \"%s\"\n", buffer);
782
783 format = "%c";
784 r = p_sprintf(buffer, format, 'a');
785 ok(r==1, "r = %d\n", r);
786 ok(!strcmp(buffer, "a"), "failed: \"%s\"\n", buffer);
787 r = p_sprintf(buffer, format, 0xa082);
788 ok(r==1, "r = %d\n", r);
789 ok(!strcmp(buffer, "\x82"), "failed: \"%s\"\n", buffer);
790
791 format = "%C";
792 r = p_sprintf(buffer, format, 'a');
793 ok(r==1, "r = %d\n", r);
794 ok(!strcmp(buffer, "a"), "failed: \"%s\"\n", buffer);
795 r = p_sprintf(buffer, format, 0x3042);
796 ok(r==0, "r = %d\n", r);
797 ok(!strcmp(buffer, ""), "failed: \"%s\"\n", buffer);
798
799 format = "a%Cb";
800 r = p_sprintf(buffer, format, 0x3042);
801 ok(r==2, "r = %d\n", r);
802 ok(!strcmp(buffer, "ab"), "failed: \"%s\"\n", buffer);
803
804 format = "%S";
805 buf_w[0] = 0x3042;
806 buf_w[1] = 0;
807 r = p_sprintf(buffer, format, buf_w);
808 ok(r==-1 || broken(!r), "r = %d\n", r);
809
810 if(!setlocale(LC_ALL, "Japanese_Japan.932")) {
811 win_skip("Japanese_Japan.932 locale not available\n");
812 return;
813 }
814
815 format = "%c";
816 r = p_sprintf(buffer, format, 0xa082);
817 ok(r==1, "r = %d\n", r);
818 ok(!strcmp(buffer, "\x82"), "failed: \"%s\"\n", buffer);
819
820 format = "%C";
821 r = p_sprintf(buffer, format, 0x3042);
822 ok(r==2, "r = %d\n", r);
823 ok(!strcmp(buffer, "\x82\xa0"), "failed: \"%s\"\n", buffer);
824
825 strcpy(buffer, " string to copy");
826 r = p_sprintf(buffer, buffer+1);
827 ok(r==14, "r = %d\n", r);
828 ok(!strcmp(buffer, "string to copy"), "failed: \"%s\"\n", buffer);
829
830 setlocale(LC_ALL, "C");
831}
832
833static void test_swprintf( void )
834{
835 wchar_t buffer[100];
836 const wchar_t I64d[] = {'%','I','6','4','d',0};
837 double pnumber=789456123;
838 const wchar_t TwentyThreePoint15e[]= {'%','+','#','2','3','.','1','5','e',0};
839 const wchar_t e008[] = {'e','+','0','0','8',0};
840 const wchar_t string_w[] = {'s','t','r','i','n','g',0};
841 const char string[] = "string";
842 const wchar_t S[]={'%','S',0};
843 const wchar_t hs[] = {'%', 'h', 's', 0};
844
845 swprintf(buffer,TwentyThreePoint15e,pnumber);
846 ok(wcsstr(buffer,e008) != 0,"Sprintf different\n");
847 swprintf(buffer,I64d,((ULONGLONG)0xffffffff)*0xffffffff);
848 ok(wcslen(buffer) == 11,"Problem with long long\n");
849 swprintf(buffer,S,string);
850 ok(wcslen(buffer) == 6,"Problem with \"%%S\" interpretation\n");
851 swprintf(buffer, hs, string);
852 ok( wcscmp(string_w,buffer) == 0, "swprintf failed with %%hs\n");
853}
854
855static void test_snprintf (void)
856{
857 struct snprintf_test {
858 const char *format;
859 int expected;
860 };
861 /* Pre-2.1 libc behaviour, not C99 compliant. */
862 const struct snprintf_test tests[] = {{"short", 5},
863 {"justfit", 7},
864 {"justfits", 8},
865 {"muchlonger", -1}};
866 char buffer[8];
867 const int bufsiz = sizeof buffer;
868 unsigned int i;
869
870 for (i = 0; i < ARRAY_SIZE(tests); i++) {
871 const char *fmt = tests[i].format;
872 const int expect = tests[i].expected;
873 const int n = _snprintf (buffer, bufsiz, fmt);
874 const int valid = n < 0 ? bufsiz : (n == bufsiz ? n : n+1);
875
876 ok (n == expect, "\"%s\": expected %d, returned %d\n",
877 fmt, expect, n);
878 ok (!memcmp (fmt, buffer, valid),
879 "\"%s\": rendered \"%.*s\"\n", fmt, valid, buffer);
880 }
881}
882
883static void test_fprintf(void)
884{
885 static const char file_name[] = "fprintf.tst";
886 static const WCHAR utf16_test[] = {'u','n','i','c','o','d','e','\n',0};
887
888 FILE *fp = fopen(file_name, "wb");
889 char buf[1024];
890 int ret;
891
892 ret = fprintf(fp, "simple test\n");
893 ok(ret == 12, "ret = %d\n", ret);
894 ret = ftell(fp);
895 ok(ret == 12, "ftell returned %d\n", ret);
896
897 ret = fprintf(fp, "contains%cnull\n", '\0');
898 ok(ret == 14, "ret = %d\n", ret);
899 ret = ftell(fp);
900 ok(ret == 26, "ftell returned %d\n", ret);
901
902 ret = fwprintf(fp, utf16_test);
903 ok(ret == 8, "ret = %d\n", ret);
904 ret = ftell(fp);
905 ok(ret == 42, "ftell returned %d\n", ret);
906
907 fclose(fp);
908
909 fp = fopen(file_name, "rb");
910 ret = fscanf(fp, "%[^\n] ", buf);
911 ok(ret == 1, "ret = %d\n", ret);
912 ret = ftell(fp);
913 ok(ret == 12, "ftell returned %d\n", ret);
914 ok(!strcmp(buf, "simple test"), "buf = %s\n", buf);
915
916 fgets(buf, sizeof(buf), fp);
917 ret = ftell(fp);
918 ok(ret == 26, "ret = %d\n", ret);
919 ok(!memcmp(buf, "contains\0null\n", 14), "buf = %s\n", buf);
920
921 memset(buf, 0, sizeof(buf));
922 fgets(buf, sizeof(buf), fp);
923 ret = ftell(fp);
924 ok(ret == 41, "ret = %d\n", ret);
925 ok(!memcmp(buf, utf16_test, sizeof(utf16_test)),
926 "buf = %s\n", wine_dbgstr_w((WCHAR*)buf));
927
928 fclose(fp);
929
930 fp = fopen(file_name, "wt");
931
932 ret = fprintf(fp, "simple test\n");
933 ok(ret == 12, "ret = %d\n", ret);
934 ret = ftell(fp);
935 ok(ret == 13, "ftell returned %d\n", ret);
936
937 ret = fprintf(fp, "contains%cnull\n", '\0');
938 ok(ret == 14, "ret = %d\n", ret);
939 ret = ftell(fp);
940 ok(ret == 28, "ftell returned %d\n", ret);
941
942 ret = fwprintf(fp, utf16_test);
943 ok(ret == 8, "ret = %d\n", ret);
944 ret = ftell(fp);
945 ok(ret == 37, "ftell returned %d\n", ret);
946
947 fclose(fp);
948
949 fp = fopen(file_name, "rb");
950 ret = fscanf(fp, "%[^\n] ", buf);
951 ok(ret == 1, "ret = %d\n", ret);
952 ret = ftell(fp);
953 ok(ret == 13, "ftell returned %d\n", ret);
954 ok(!strcmp(buf, "simple test\r"), "buf = %s\n", buf);
955
956 fgets(buf, sizeof(buf), fp);
957 ret = ftell(fp);
958 ok(ret == 28, "ret = %d\n", ret);
959 ok(!memcmp(buf, "contains\0null\r\n", 15), "buf = %s\n", buf);
960
961 fgets(buf, sizeof(buf), fp);
962 ret = ftell(fp);
963 ok(ret == 37, "ret = %d\n", ret);
964 ok(!strcmp(buf, "unicode\r\n"), "buf = %s\n", buf);
965
966 fclose(fp);
967 unlink(file_name);
968}
969
970static void test_fcvt(void)
971{
972 char *str;
973 int dec=100, sign=100;
974
975 /* Numbers less than 1.0 with different precisions */
976 str = _fcvt(0.0001, 1, &dec, &sign );
977 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
978 ok( -3 == dec, "dec wrong %d\n", dec);
979 ok( 0 == sign, "sign wrong\n");
980
981 str = _fcvt(0.0001, -10, &dec, &sign );
982 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
983 ok( -3 == dec, "dec wrong %d\n", dec);
984 ok( 0 == sign, "sign wrong\n");
985
986 str = _fcvt(0.0001, 10, &dec, &sign );
987 ok( 0 == strcmp(str,"1000000"), "bad return '%s'\n", str);
988 ok( -3 == dec, "dec wrong %d\n", dec);
989 ok( 0 == sign, "sign wrong\n");
990
991 /* Basic sign test */
992 str = _fcvt(-111.0001, 5, &dec, &sign );
993 ok( 0 == strcmp(str,"11100010"), "bad return '%s'\n", str);
994 ok( 3 == dec, "dec wrong %d\n", dec);
995 ok( 1 == sign, "sign wrong\n");
996
997 str = _fcvt(111.0001, 5, &dec, &sign );
998 ok( 0 == strcmp(str,"11100010"), "bad return '%s'\n", str);
999 ok( 3 == dec, "dec wrong\n");
1000 ok( 0 == sign, "sign wrong\n");
1001
1002 /* 0.0 with different precisions */
1003 str = _fcvt(0.0, 5, &dec, &sign );
1004 ok( 0 == strcmp(str,"00000"), "bad return '%s'\n", str);
1005 ok( 0 == dec, "dec wrong %d\n", dec);
1006 ok( 0 == sign, "sign wrong\n");
1007
1008 str = _fcvt(0.0, 0, &dec, &sign );
1009 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
1010 ok( 0 == dec, "dec wrong %d\n", dec);
1011 ok( 0 == sign, "sign wrong\n");
1012
1013 str = _fcvt(0.0, -1, &dec, &sign );
1014 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
1015 ok( 0 == dec, "dec wrong %d\n", dec);
1016 ok( 0 == sign, "sign wrong\n");
1017
1018 /* Numbers > 1.0 with 0 or -ve precision */
1019 str = _fcvt(-123.0001, 0, &dec, &sign );
1020 ok( 0 == strcmp(str,"123"), "bad return '%s'\n", str);
1021 ok( 3 == dec, "dec wrong %d\n", dec);
1022 ok( 1 == sign, "sign wrong\n");
1023
1024 str = _fcvt(-123.0001, -1, &dec, &sign );
1025 ok( 0 == strcmp(str,"12"), "bad return '%s'\n", str);
1026 ok( 3 == dec, "dec wrong %d\n", dec);
1027 ok( 1 == sign, "sign wrong\n");
1028
1029 str = _fcvt(-123.0001, -2, &dec, &sign );
1030 ok( 0 == strcmp(str,"1"), "bad return '%s'\n", str);
1031 ok( 3 == dec, "dec wrong %d\n", dec);
1032 ok( 1 == sign, "sign wrong\n");
1033
1034 str = _fcvt(-123.0001, -3, &dec, &sign );
1035 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
1036 ok( 3 == dec, "dec wrong %d\n", dec);
1037 ok( 1 == sign, "sign wrong\n");
1038
1039 /* Numbers > 1.0, but with rounding at the point of precision */
1040 str = _fcvt(99.99, 1, &dec, &sign );
1041 ok( 0 == strcmp(str,"1000"), "bad return '%s'\n", str);
1042 ok( 3 == dec, "dec wrong %d\n", dec);
1043 ok( 0 == sign, "sign wrong\n");
1044
1045 /* Numbers < 1.0 where rounding occurs at the point of precision */
1046 str = _fcvt(0.00636, 2, &dec, &sign );
1047 ok( 0 == strcmp(str,"1"), "bad return '%s'\n", str);
1048 ok( -1 == dec, "dec wrong %d\n", dec);
1049 ok( 0 == sign, "sign wrong\n");
1050
1051 str = _fcvt(0.00636, 3, &dec, &sign );
1052 ok( 0 == strcmp(str,"6"), "bad return '%s'\n", str);
1053 ok( -2 == dec, "dec wrong %d\n", dec);
1054 ok( 0 == sign, "sign wrong\n");
1055
1056 str = _fcvt(0.09999999996, 2, &dec, &sign );
1057 ok( 0 == strcmp(str,"10"), "bad return '%s'\n", str);
1058 ok( 0 == dec, "dec wrong %d\n", dec);
1059 ok( 0 == sign, "sign wrong\n");
1060
1061 str = _fcvt(0.6, 0, &dec, &sign );
1062 ok( 0 == strcmp(str,"1"), "bad return '%s'\n", str);
1063 ok( 1 == dec, "dec wrong %d\n", dec);
1064 ok( 0 == sign, "sign wrong\n");
1065}
1066
1067/* Don't test nrdigits < 0, msvcrt on Win9x and NT4 will corrupt memory by
1068 * writing outside allocated memory */
1069static struct {
1070 double value;
1071 int nrdigits;
1072 const char *expstr_e;
1073 const char *expstr_f;
1074 int expdecpt_e;
1075 int expdecpt_f;
1076 int expsign;
1077} test_cvt_testcases[] = {
1078 { 45.0, 2, "45", "4500", 2, 2, 0 },
1079 /* Numbers less than 1.0 with different precisions */
1080 { 0.0001, 1, "1", "", -3, -3, 0 },
1081 { 0.0001, 10,"1000000000", "1000000", -3, -3, 0 },
1082 /* Basic sign test */
1083 { -111.0001, 5, "11100", "11100010", 3, 3, 1 },
1084 { 111.0001, 5, "11100", "11100010", 3, 3, 0 },
1085 /* big numbers with low precision */
1086 { 3333.3, 2, "33", "333330", 4, 4, 0 },
1087 {999999999999.9, 3, "100","999999999999900", 13, 12, 0 },
1088 /* 0.0 with different precisions */
1089 { 0.0, 5, "00000", "00000", 0, 0, 0 },
1090 { 0.0, 0, "", "", 0, 0, 0 },
1091 { 0.0, -1, "", "", 0, 0, 0 },
1092 /* Numbers > 1.0 with 0 or -ve precision */
1093 { -123.0001, 0, "", "123", 3, 3, 1 },
1094 { -123.0001, -1, "", "12", 3, 3, 1 },
1095 { -123.0001, -2, "", "1", 3, 3, 1 },
1096 { -123.0001, -3, "", "", 3, 3, 1 },
1097 /* Numbers > 1.0, but with rounding at the point of precision */
1098 { 99.99, 1, "1", "1000", 3, 3, 0 },
1099 /* Numbers < 1.0 where rounding occurs at the point of precision */
1100 { 0.0063, 2, "63", "1", -2, -1, 0 },
1101 { 0.0063, 3, "630", "6", -2, -2, 0 },
1102 { 0.09999999996, 2, "10", "10", 0, 0, 0 },
1103 { 0.6, 1, "6", "6", 0, 0, 0 },
1104 { 0.6, 0, "", "1", 1, 1, 0 },
1105 { 0.4, 0, "", "", 0, 0, 0 },
1106 { 0.49, 0, "", "", 0, 0, 0 },
1107 { 0.51, 0, "", "1", 1, 1, 0 },
1108 /* ask for ridiculous precision, ruin formatting this table */
1109 { 1.0, 30, "100000000000000000000000000000",
1110 "1000000000000000000000000000000", 1, 1, 0},
1111 { 123456789012345678901.0, 30, "123456789012345680000000000000",
1112 "123456789012345680000000000000000000000000000000000", 21, 21, 0},
1113 /* end marker */
1114 { 0, 0, "END"}
1115};
1116
1117static void test_xcvt(void)
1118{
1119 char *str;
1120 int i, decpt, sign, err;
1121
1122 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
1123 decpt = sign = 100;
1124 str = _ecvt( test_cvt_testcases[i].value,
1125 test_cvt_testcases[i].nrdigits,
1126 &decpt,
1127 &sign);
1128 ok( 0 == strncmp( str, test_cvt_testcases[i].expstr_e, 15),
1129 "_ecvt() bad return, got \n'%s' expected \n'%s'\n", str,
1130 test_cvt_testcases[i].expstr_e);
1131 ok( decpt == test_cvt_testcases[i].expdecpt_e,
1132 "_ecvt() decimal point wrong, got %d expected %d\n", decpt,
1133 test_cvt_testcases[i].expdecpt_e);
1134 ok( sign == test_cvt_testcases[i].expsign,
1135 "_ecvt() sign wrong, got %d expected %d\n", sign,
1136 test_cvt_testcases[i].expsign);
1137 }
1138 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
1139 decpt = sign = 100;
1140 str = _fcvt( test_cvt_testcases[i].value,
1141 test_cvt_testcases[i].nrdigits,
1142 &decpt,
1143 &sign);
1144 ok( 0 == strncmp( str, test_cvt_testcases[i].expstr_f, 15),
1145 "_fcvt() bad return, got \n'%s' expected \n'%s'\n", str,
1146 test_cvt_testcases[i].expstr_f);
1147 ok( decpt == test_cvt_testcases[i].expdecpt_f,
1148 "_fcvt() decimal point wrong, got %d expected %d\n", decpt,
1149 test_cvt_testcases[i].expdecpt_f);
1150 ok( sign == test_cvt_testcases[i].expsign,
1151 "_fcvt() sign wrong, got %d expected %d\n", sign,
1152 test_cvt_testcases[i].expsign);
1153 }
1154
1155 if (p__ecvt_s)
1156 {
1157 str = malloc(1024);
1158 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
1159 decpt = sign = 100;
1160 err = p__ecvt_s(str, 1024, test_cvt_testcases[i].value, test_cvt_testcases[i].nrdigits, &decpt, &sign);
1161 ok(err == 0, "_ecvt_s() failed with error code %d\n", err);
1162 ok( 0 == strncmp( str, test_cvt_testcases[i].expstr_e, 15),
1163 "_ecvt_s() bad return, got \n'%s' expected \n'%s'\n", str,
1164 test_cvt_testcases[i].expstr_e);
1165 ok( decpt == test_cvt_testcases[i].expdecpt_e,
1166 "_ecvt_s() decimal point wrong, got %d expected %d\n", decpt,
1167 test_cvt_testcases[i].expdecpt_e);
1168 ok( sign == test_cvt_testcases[i].expsign,
1169 "_ecvt_s() sign wrong, got %d expected %d\n", sign,
1170 test_cvt_testcases[i].expsign);
1171 }
1172 free(str);
1173 }
1174 else
1175 win_skip("_ecvt_s not available\n");
1176
1177 if (p__fcvt_s)
1178 {
1179 int i;
1180
1181 str = malloc(1024);
1182
1183 /* invalid arguments */
1184 err = p__fcvt_s(NULL, 0, 0.0, 0, &i, &i);
1185 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
1186
1187 err = p__fcvt_s(str, 0, 0.0, 0, &i, &i);
1188 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
1189
1190 str[0] = ' ';
1191 str[1] = 0;
1192 err = p__fcvt_s(str, -1, 0.0, 0, &i, &i);
1193 ok(err == 0, "got %d, expected 0\n", err);
1194 ok(str[0] == 0, "got %c, expected 0\n", str[0]);
1195 ok(str[1] == 0, "got %c, expected 0\n", str[1]);
1196
1197 err = p__fcvt_s(str, 1, 0.0, 0, NULL, &i);
1198 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
1199
1200 err = p__fcvt_s(str, 1, 0.0, 0, &i, NULL);
1201 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
1202
1203 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
1204 decpt = sign = 100;
1205 err = p__fcvt_s(str, 1024, test_cvt_testcases[i].value, test_cvt_testcases[i].nrdigits, &decpt, &sign);
1206 ok(err == 0, "_fcvt_s() failed with error code %d\n", err);
1207 ok( 0 == strncmp( str, test_cvt_testcases[i].expstr_f, 15),
1208 "_fcvt_s() bad return, got '%s' expected '%s'. test %d\n", str,
1209 test_cvt_testcases[i].expstr_f, i);
1210 ok( decpt == test_cvt_testcases[i].expdecpt_f,
1211 "_fcvt_s() decimal point wrong, got %d expected %d\n", decpt,
1212 test_cvt_testcases[i].expdecpt_f);
1213 ok( sign == test_cvt_testcases[i].expsign,
1214 "_fcvt_s() sign wrong, got %d expected %d\n", sign,
1215 test_cvt_testcases[i].expsign);
1216 }
1217 free(str);
1218 }
1219 else
1220 win_skip("_fcvt_s not available\n");
1221}
1222
1223static int WINAPIV _vsnwprintf_wrapper(wchar_t *str, size_t len, const wchar_t *format, ...)
1224{
1225 int ret;
1226 __ms_va_list valist;
1227 __ms_va_start(valist, format);
1228 ret = _vsnwprintf(str, len, format, valist);
1229 __ms_va_end(valist);
1230 return ret;
1231}
1232
1233static void test_vsnwprintf(void)
1234{
1235 const wchar_t format[] = {'%','w','s','%','w','s','%','w','s',0};
1236 const wchar_t one[] = {'o','n','e',0};
1237 const wchar_t two[] = {'t','w','o',0};
1238 const wchar_t three[] = {'t','h','r','e','e',0};
1239
1240 int ret;
1241 wchar_t str[32];
1242 char buf[32];
1243
1244 ret = _vsnwprintf_wrapper( str, ARRAY_SIZE(str), format, one, two, three );
1245
1246 ok( ret == 11, "got %d expected 11\n", ret );
1247 WideCharToMultiByte( CP_ACP, 0, str, -1, buf, sizeof(buf), NULL, NULL );
1248 ok( !strcmp(buf, "onetwothree"), "got %s expected 'onetwothree'\n", buf );
1249
1250 ret = _vsnwprintf_wrapper( str, 0, format, one, two, three );
1251 ok( ret == -1, "got %d, expected -1\n", ret );
1252
1253 ret = _vsnwprintf_wrapper( NULL, 0, format, one, two, three );
1254 ok( ret == 11 || broken(ret == -1 /* Win2k */), "got %d, expected 11\n", ret );
1255}
1256
1257static int WINAPIV vswprintf_wrapper(wchar_t *str, const wchar_t *format, ...)
1258{
1259 int ret;
1260 __ms_va_list valist;
1261 __ms_va_start(valist, format);
1262 ret = p_vswprintf(str, format, valist);
1263 __ms_va_end(valist);
1264 return ret;
1265}
1266
1267static int WINAPIV _vswprintf_wrapper(wchar_t *str, const wchar_t *format, ...)
1268{
1269 int ret;
1270 __ms_va_list valist;
1271 __ms_va_start(valist, format);
1272 ret = p__vswprintf(str, format, valist);
1273 __ms_va_end(valist);
1274 return ret;
1275}
1276
1277static int WINAPIV _vswprintf_l_wrapper(wchar_t *str, const wchar_t *format, void *locale, ...)
1278{
1279 int ret;
1280 __ms_va_list valist;
1281 __ms_va_start(valist, locale);
1282 ret = p__vswprintf_l(str, format, locale, valist);
1283 __ms_va_end(valist);
1284 return ret;
1285}
1286
1287static int WINAPIV _vswprintf_c_wrapper(wchar_t *str, size_t size, const wchar_t *format, ...)
1288{
1289 int ret;
1290 __ms_va_list valist;
1291 __ms_va_start(valist, format);
1292 ret = p__vswprintf_c(str, size, format, valist);
1293 __ms_va_end(valist);
1294 return ret;
1295}
1296
1297static int WINAPIV _vswprintf_c_l_wrapper(wchar_t *str, size_t size, const wchar_t *format, void *locale, ...)
1298{
1299 int ret;
1300 __ms_va_list valist;
1301 __ms_va_start(valist, locale);
1302 ret = p__vswprintf_c_l(str, size, format, locale, valist);
1303 __ms_va_end(valist);
1304 return ret;
1305}
1306
1307static int WINAPIV _vswprintf_p_l_wrapper(wchar_t *str, size_t size, const wchar_t *format, void *locale, ...)
1308{
1309 int ret;
1310 __ms_va_list valist;
1311 __ms_va_start(valist, locale);
1312 ret = p__vswprintf_p_l(str, size, format, locale, valist);
1313 __ms_va_end(valist);
1314 return ret;
1315}
1316
1317static void test_vswprintf(void)
1318{
1319 const wchar_t format[] = {'%','s',' ','%','d',0};
1320 const wchar_t number[] = {'n','u','m','b','e','r',0};
1321 const wchar_t out[] = {'n','u','m','b','e','r',' ','1','2','3',0};
1322 wchar_t buf[20];
1323
1324 int ret;
1325
1326 if (!p_vswprintf || !p__vswprintf || !p__vswprintf_l ||!p__vswprintf_c
1327 || !p__vswprintf_c_l || !p__vswprintf_p_l)
1328 {
1329 win_skip("_vswprintf or vswprintf not available\n");
1330 return;
1331 }
1332
1333 ret = vswprintf_wrapper(buf, format, number, 123);
1334 ok(ret == 10, "got %d, expected 10\n", ret);
1335 ok(!memcmp(buf, out, sizeof(out)), "buf = %s\n", wine_dbgstr_w(buf));
1336
1337 memset(buf, 0, sizeof(buf));
1338 ret = _vswprintf_wrapper(buf, format, number, 123);
1339 ok(ret == 10, "got %d, expected 10\n", ret);
1340 ok(!memcmp(buf, out, sizeof(out)), "buf = %s\n", wine_dbgstr_w(buf));
1341
1342 memset(buf, 0, sizeof(buf));
1343 ret = _vswprintf_l_wrapper(buf, format, NULL, number, 123);
1344 ok(ret == 10, "got %d, expected 10\n", ret);
1345 ok(!memcmp(buf, out, sizeof(out)), "buf = %s\n", wine_dbgstr_w(buf));
1346
1347 memset(buf, 0, sizeof(buf));
1348 ret = _vswprintf_c_wrapper(buf, 20, format, number, 123);
1349 ok(ret == 10, "got %d, expected 10\n", ret);
1350 ok(!memcmp(buf, out, sizeof(out)), "buf = %s\n", wine_dbgstr_w(buf));
1351
1352 memset(buf, 0, sizeof(buf));
1353 ret = _vswprintf_c_l_wrapper(buf, 20, format, NULL, number, 123);
1354 ok(ret == 10, "got %d, expected 10\n", ret);
1355 ok(!memcmp(buf, out, sizeof(out)), "buf = %s\n", wine_dbgstr_w(buf));
1356
1357 memset(buf, 0, sizeof(buf));
1358 ret = _vswprintf_p_l_wrapper(buf, 20, format, NULL, number, 123);
1359 ok(ret == 10, "got %d, expected 10\n", ret);
1360 ok(!memcmp(buf, out, sizeof(out)), "buf = %s\n", wine_dbgstr_w(buf));
1361}
1362
1363static int WINAPIV _vscprintf_wrapper(const char *format, ...)
1364{
1365 int ret;
1366 __ms_va_list valist;
1367 __ms_va_start(valist, format);
1368 ret = p__vscprintf(format, valist);
1369 __ms_va_end(valist);
1370 return ret;
1371}
1372
1373static void test_vscprintf(void)
1374{
1375 int ret;
1376
1377 if (!p__vscprintf)
1378 {
1379 win_skip("_vscprintf not available\n");
1380 return;
1381 }
1382
1383 ret = _vscprintf_wrapper( "%s %d", "number", 1 );
1384 ok( ret == 8, "got %d expected 8\n", ret );
1385}
1386
1387static int WINAPIV _vscwprintf_wrapper(const wchar_t *format, ...)
1388{
1389 int ret;
1390 __ms_va_list valist;
1391 __ms_va_start(valist, format);
1392 ret = p__vscwprintf(format, valist);
1393 __ms_va_end(valist);
1394 return ret;
1395}
1396
1397static void test_vscwprintf(void)
1398{
1399 const wchar_t format[] = {'%','s',' ','%','d',0};
1400 const wchar_t number[] = {'n','u','m','b','e','r',0};
1401
1402 int ret;
1403
1404 if (!p__vscwprintf)
1405 {
1406 win_skip("_vscwprintf not available\n");
1407 return;
1408 }
1409
1410 ret = _vscwprintf_wrapper( format, number, 1 );
1411 ok( ret == 8, "got %d expected 8\n", ret );
1412}
1413
1414static int WINAPIV _vsnwprintf_s_wrapper(wchar_t *str, size_t sizeOfBuffer,
1415 size_t count, const wchar_t *format, ...)
1416{
1417 int ret;
1418 __ms_va_list valist;
1419 __ms_va_start(valist, format);
1420 ret = p__vsnwprintf_s(str, sizeOfBuffer, count, format, valist);
1421 __ms_va_end(valist);
1422 return ret;
1423}
1424
1425static void test_vsnwprintf_s(void)
1426{
1427 const wchar_t format[] = { 'A','B','%','u','C',0 };
1428 const wchar_t out7[] = { 'A','B','1','2','3','C',0 };
1429 const wchar_t out6[] = { 'A','B','1','2','3',0 };
1430 const wchar_t out2[] = { 'A',0 };
1431 const wchar_t out1[] = { 0 };
1432 wchar_t buffer[14] = { 0 };
1433 int exp, got;
1434
1435 if (!p__vsnwprintf_s)
1436 {
1437 win_skip("_vsnwprintf_s not available\n");
1438 return;
1439 }
1440
1441 /* Enough room. */
1442 exp = wcslen(out7);
1443
1444 got = _vsnwprintf_s_wrapper(buffer, 14, _TRUNCATE, format, 123);
1445 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
1446 ok( !wcscmp(out7, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1447
1448 got = _vsnwprintf_s_wrapper(buffer, 12, _TRUNCATE, format, 123);
1449 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
1450 ok( !wcscmp(out7, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1451
1452 got = _vsnwprintf_s_wrapper(buffer, 7, _TRUNCATE, format, 123);
1453 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
1454 ok( !wcscmp(out7, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1455
1456 /* Not enough room. */
1457 exp = -1;
1458
1459 got = _vsnwprintf_s_wrapper(buffer, 6, _TRUNCATE, format, 123);
1460 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
1461 ok( !wcscmp(out6, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1462
1463 got = _vsnwprintf_s_wrapper(buffer, 2, _TRUNCATE, format, 123);
1464 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
1465 ok( !wcscmp(out2, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1466
1467 got = _vsnwprintf_s_wrapper(buffer, 1, _TRUNCATE, format, 123);
1468 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
1469 ok( !wcscmp(out1, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1470}
1471
1472static int WINAPIV _vsprintf_p_wrapper(char *str, size_t sizeOfBuffer,
1473 const char *format, ...)
1474{
1475 int ret;
1476 __ms_va_list valist;
1477 __ms_va_start(valist, format);
1478 ret = p__vsprintf_p(str, sizeOfBuffer, format, valist);
1479 __ms_va_end(valist);
1480 return ret;
1481}
1482
1483static void test_vsprintf_p(void)
1484{
1485 char buf[1024];
1486 int ret;
1487
1488 if(!p__vsprintf_p) {
1489 win_skip("vsprintf_p not available\n");
1490 return;
1491 }
1492
1493 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%s %d", "test", 1234);
1494 ok(ret == 9, "ret = %d\n", ret);
1495 ok(!memcmp(buf, "test 1234", 10), "buf = %s\n", buf);
1496
1497 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%1$d", 1234, "additional param");
1498 ok(ret == 4, "ret = %d\n", ret);
1499 ok(!memcmp(buf, "1234", 5), "buf = %s\n", buf);
1500
1501 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%2$s %1$d", 1234, "test");
1502 ok(ret == 9, "ret = %d\n", ret);
1503 ok(!memcmp(buf, "test 1234", 10), "buf = %s\n", buf);
1504
1505 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%2$*3$s %2$.*1$s", 2, "test", 3);
1506 ok(ret == 7, "ret = %d\n", ret);
1507 ok(!memcmp(buf, "test te", 8), "buf = %s\n", buf);
1508
1509 /* Following test invokes invalid parameter handler */
1510 /* ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%d %1$d", 1234); */
1511}
1512
1513static void test__get_output_format(void)
1514{
1515 unsigned int ret;
1516 char buf[64];
1517 int c;
1518
1519 if (!p__get_output_format || !p__set_output_format)
1520 {
1521 win_skip("_get_output_format or _set_output_format is not available\n");
1522 return;
1523 }
1524
1525 ret = p__get_output_format();
1526 ok(ret == 0, "got %d\n", ret);
1527
1528 c = p_sprintf(buf, "%E", 1.23);
1529 ok(c == 13, "c = %d\n", c);
1530 ok(!strcmp(buf, "1.230000E+000"), "buf = %s\n", buf);
1531
1532 ret = p__set_output_format(_TWO_DIGIT_EXPONENT);
1533 ok(ret == 0, "got %d\n", ret);
1534
1535 c = p_sprintf(buf, "%E", 1.23);
1536 ok(c == 12, "c = %d\n", c);
1537 ok(!strcmp(buf, "1.230000E+00"), "buf = %s\n", buf);
1538
1539 ret = p__get_output_format();
1540 ok(ret == _TWO_DIGIT_EXPONENT, "got %d\n", ret);
1541
1542 ret = p__set_output_format(_TWO_DIGIT_EXPONENT);
1543 ok(ret == _TWO_DIGIT_EXPONENT, "got %d\n", ret);
1544}
1545
1546START_TEST(printf)
1547{
1548 init();
1549
1550 test_sprintf();
1551 test_swprintf();
1552 test_snprintf();
1553 test_fprintf();
1554 test_fcvt();
1555 test_xcvt();
1556 test_vsnwprintf();
1557 test_vscprintf();
1558 test_vscwprintf();
1559 test_vswprintf();
1560 test_vsnwprintf_s();
1561 test_vsprintf_p();
1562 test__get_output_format();
1563}
dec
ios_base &_STLP_CALL dec(ios_base &__s)
Definition: _ios_base.h:321
broken
#define broken(x)
Definition: _sntprintf.h:21
EINVAL
#define EINVAL
Definition: acclib.h:90
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
strncmp
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
strcpy
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
__cdecl
#define __cdecl
Definition: accygwin.h:79
ok
#define ok(value,...)
Definition: atltest.h:57
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:33
locale
Definition: _locale.h:75
_TRUNCATE
#define _TRUNCATE
Definition: crtdefs.h:262
free
#define free
Definition: debug_ros.c:5
malloc
#define malloc
Definition: debug_ros.c:4
NULL
#define NULL
Definition: types.h:112
CP_ACP
#define CP_ACP
Definition: compat.h:109
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
swprintf
#define swprintf
Definition: precomp.h:40
printf
#define printf
Definition: freeldr.h:94
valid
BOOLEAN valid
Definition: fxregistryapi.cpp:1474
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
size
GLsizeiptr size
Definition: glext.h:5919
n
GLdouble n
Definition: glext.h:7729
buffer
GLuint buffer
Definition: glext.h:5915
c
const GLubyte * c
Definition: glext.h:8905
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
len
GLenum GLsizei len
Definition: glext.h:6722
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
two
static double two
Definition: jn_yn.c:52
LC_ALL
#define LC_ALL
Definition: locale.h:17
_TWO_DIGIT_EXPONENT
#define _TWO_DIGIT_EXPONENT
Definition: stdio.h:138
fscanf
_Check_return_ _CRTIMP int __cdecl fscanf(_Inout_ FILE *_File, _In_z_ _Scanf_format_string_ const char *_Format,...)
fprintf
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
fopen
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
_vsnwprintf
_CRTIMP int __cdecl _vsnwprintf(wchar_t *_Dest, size_t _Count, const wchar_t *_Format, va_list _Args)
fgets
_Check_return_opt_ _CRTIMP char *__cdecl fgets(_Out_writes_z_(_MaxCount) char *_Buf, _In_ int _MaxCount, _Inout_ FILE *_File)
fclose
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
fwprintf
_Check_return_opt_ _CRTIMP int __cdecl fwprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const wchar_t *_Format,...)
ftell
_Check_return_ _CRTIMP long __cdecl ftell(_Inout_ FILE *_File)
_ecvt
_Check_return_ _CRTIMP char *__cdecl _ecvt(_In_ double _Val, _In_ int _NumOfDigits, _Out_ int *_PtDec, _Out_ int *_PtSign)
_fcvt
_Check_return_ _CRTIMP char *__cdecl _fcvt(_In_ double _Val, _In_ int _NumOfDec, _Out_ int *_PtDec, _Out_ int *_PtSign)
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
wcsstr
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
c
#define c
Definition: ke_i.h:80
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
unlink
#define unlink
Definition: syshdrs.h:54
tests
static struct test_info tests[]
hmod
static PEXPLICIT_ACCESSW *static HMODULE hmod
Definition: security.c:143
expect
#define expect(expected, got)
Definition: combo.c:36
expected
BOOL expected
Definition: store.c:2063
_vsnwprintf_wrapper
static int WINAPIV _vsnwprintf_wrapper(wchar_t *str, size_t len, const wchar_t *format,...)
Definition: printf.c:1223
size_t
static static size_t
Definition: printf.c:78
test_vsnwprintf_s
static void test_vsnwprintf_s(void)
Definition: printf.c:1425
expstr_f
const char * expstr_f
Definition: printf.c:1073
test_vsnwprintf
static void test_vsnwprintf(void)
Definition: printf.c:1233
_vscwprintf_wrapper
static int WINAPIV _vscwprintf_wrapper(const wchar_t *format,...)
Definition: printf.c:1387
init
static void init(void)
Definition: printf.c:90
vswprintf_wrapper
static int WINAPIV vswprintf_wrapper(wchar_t *str, const wchar_t *format,...)
Definition: printf.c:1257
test_swprintf
static void test_swprintf(void)
Definition: printf.c:833
_vsprintf_p_wrapper
static int WINAPIV _vsprintf_p_wrapper(char *str, size_t sizeOfBuffer, const char *format,...)
Definition: printf.c:1472
expstr_e
const char * expstr_e
Definition: printf.c:1072
test_cvt_testcases
static struct @1657 test_cvt_testcases[]
_vswprintf_p_l_wrapper
static int WINAPIV _vswprintf_p_l_wrapper(wchar_t *str, size_t size, const wchar_t *format, void *locale,...)
Definition: printf.c:1307
test_sprintf
static void test_sprintf(void)
Definition: printf.c:111
_vswprintf_l_wrapper
static int WINAPIV _vswprintf_l_wrapper(wchar_t *str, const wchar_t *format, void *locale,...)
Definition: printf.c:1277
__port_ind
static float __port_ind(void)
Definition: printf.c:59
test__get_output_format
static void test__get_output_format(void)
Definition: printf.c:1513
count
static size_t size_t count
Definition: printf.c:69
expdecpt_e
int expdecpt_e
Definition: printf.c:1074
test_vsprintf_p
static void test_vsprintf_p(void)
Definition: printf.c:1483
expdecpt_f
int expdecpt_f
Definition: printf.c:1075
sizeOfBuffer
static size_t sizeOfBuffer
Definition: printf.c:68
format
static size_t size_t const wchar_t * format
Definition: printf.c:69
nrdigits
int nrdigits
Definition: printf.c:1071
IND
#define IND
Definition: printf.c:64
test_vscprintf
static void test_vscprintf(void)
Definition: printf.c:1373
size
static size_t size
Definition: printf.c:83
valist
static __ms_va_list valist
Definition: printf.c:66
NAN
#define NAN
Definition: printf.c:55
test_fprintf
static void test_fprintf(void)
Definition: printf.c:883
INFINITY
#define INFINITY
Definition: printf.c:48
locale
static const wchar_t void * locale
Definition: printf.c:82
sign
static size_t double int int int * sign
Definition: printf.c:72
_vsnwprintf_s_wrapper
static int WINAPIV _vsnwprintf_s_wrapper(wchar_t *str, size_t sizeOfBuffer, size_t count, const wchar_t *format,...)
Definition: printf.c:1414
_vswprintf_c_l_wrapper
static int WINAPIV _vswprintf_c_l_wrapper(wchar_t *str, size_t size, const wchar_t *format, void *locale,...)
Definition: printf.c:1297
__port_infinity
static float __port_infinity(void)
Definition: printf.c:43
test_snprintf
static void test_snprintf(void)
Definition: printf.c:855
_vswprintf_wrapper
static int WINAPIV _vswprintf_wrapper(wchar_t *str, const wchar_t *format,...)
Definition: printf.c:1267
test_vscwprintf
static void test_vscwprintf(void)
Definition: printf.c:1397
ndigits
static size_t double int ndigits
Definition: printf.c:72
test_vswprintf
static void test_vswprintf(void)
Definition: printf.c:1317
decpt
static size_t double int int * decpt
Definition: printf.c:72
number
static size_t double number
Definition: printf.c:71
expsign
int expsign
Definition: printf.c:1076
_vswprintf_c_wrapper
static int WINAPIV _vswprintf_c_wrapper(wchar_t *str, size_t size, const wchar_t *format,...)
Definition: printf.c:1287
__ms_va_list
static static const char __ms_va_list
Definition: printf.c:78
length
static size_t length
Definition: printf.c:71
test_fcvt
static void test_fcvt(void)
Definition: printf.c:970
_vscprintf_wrapper
static int WINAPIV _vscprintf_wrapper(const char *format,...)
Definition: printf.c:1363
__port_nan
static float __port_nan(void)
Definition: printf.c:50
test_xcvt
static void test_xcvt(void)
Definition: printf.c:1117
file_name
static LPCWSTR file_name
Definition: protocol.c:147
exp
DWORD exp
Definition: msg.c:16058
err
#define err(...)
Definition: reactos_support_code.h:30
out
static FILE * out
Definition: regtests2xml.c:44
str
const WCHAR * str
Definition: rpc_transport.c:2724
WINAPIV
#define WINAPIV
Definition: sdbpapi.h:64
wcscmp
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
win_skip
#define win_skip
Definition: test.h:160
memset
#define memset(x, y, z)
Definition: compat.h:39
one
int one
Definition: sehframes.cpp:28
S
Definition: movable.cpp:9
_iobuf
Definition: mbstring.h:19
fmt
Definition: dsound.c:943
setlocale
#define setlocale(n, s)
Definition: locale.h:46
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:68
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
value
Definition: pdh_main.c:94
ret
int ret
Definition: wcstombs-tests.c:31
__ms_va_end
#define __ms_va_end(list)
Definition: windef.h:458
__ms_va_start
#define __ms_va_start(list, arg)
Definition: windef.h:457
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
_snprintf
#define _snprintf
Definition: xmlstorage.h:200