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
__port_infinity(void)43 static 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
__port_nan(void)50 static 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
__port_ind(void)59 static 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
66 static int (__cdecl *p__vscprintf)(const char *format, __ms_va_list valist);
67 static int (__cdecl *p__vscwprintf)(const wchar_t *format, __ms_va_list valist);
68 static int (__cdecl *p__vsnwprintf_s)(wchar_t *str, size_t sizeOfBuffer,
69 size_t count, const wchar_t *format,
70 __ms_va_list valist);
71 static int (__cdecl *p__ecvt_s)(char *buffer, size_t length, double number,
72 int ndigits, int *decpt, int *sign);
73 static int (__cdecl *p__fcvt_s)(char *buffer, size_t length, double number,
74 int ndigits, int *decpt, int *sign);
75 static unsigned int (__cdecl *p__get_output_format)(void);
76 static unsigned int (__cdecl *p__set_output_format)(unsigned int);
77 static int (WINAPIV *p_sprintf)(char*, ...);
78 static int (__cdecl *p__vsprintf_p)(char*, size_t, const char*, __ms_va_list);
79 static int (__cdecl *p_vswprintf)(wchar_t *str, const wchar_t *format, __ms_va_list valist);
80 static int (__cdecl *p__vswprintf)(wchar_t *str, const wchar_t *format, __ms_va_list valist);
81 static int (__cdecl *p__vswprintf_l)(wchar_t *str, const wchar_t *format,
82 void *locale, __ms_va_list valist);
83 static int (__cdecl *p__vswprintf_c)(wchar_t *str, size_t size, const wchar_t *format,
84 __ms_va_list valist);
85 static int (__cdecl *p__vswprintf_c_l)(wchar_t *str, size_t size, const wchar_t *format,
86 void *locale, __ms_va_list valist);
87 static int (__cdecl *p__vswprintf_p_l)(wchar_t *str, size_t size, const wchar_t *format,
88 void *locale, __ms_va_list valist);
89
init(void)90 static 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
test_sprintf(void)111 static 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
test_swprintf(void)833 static 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
test_snprintf(void)855 static 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
test_fprintf(void)883 static 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
test_fcvt(void)970 static 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 */
1069 static 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
test_xcvt(void)1117 static 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
_vsnwprintf_wrapper(wchar_t * str,size_t len,const wchar_t * format,...)1223 static 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
test_vsnwprintf(void)1233 static 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
vswprintf_wrapper(wchar_t * str,const wchar_t * format,...)1257 static 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
_vswprintf_wrapper(wchar_t * str,const wchar_t * format,...)1267 static 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
_vswprintf_l_wrapper(wchar_t * str,const wchar_t * format,void * locale,...)1277 static 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
_vswprintf_c_wrapper(wchar_t * str,size_t size,const wchar_t * format,...)1287 static 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
_vswprintf_c_l_wrapper(wchar_t * str,size_t size,const wchar_t * format,void * locale,...)1297 static 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
_vswprintf_p_l_wrapper(wchar_t * str,size_t size,const wchar_t * format,void * locale,...)1307 static 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
test_vswprintf(void)1317 static 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
_vscprintf_wrapper(const char * format,...)1363 static 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
test_vscprintf(void)1373 static 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
_vscwprintf_wrapper(const wchar_t * format,...)1387 static 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
test_vscwprintf(void)1397 static 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
_vsnwprintf_s_wrapper(wchar_t * str,size_t sizeOfBuffer,size_t count,const wchar_t * format,...)1414 static 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
test_vsnwprintf_s(void)1425 static 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
_vsprintf_p_wrapper(char * str,size_t sizeOfBuffer,const char * format,...)1472 static 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
test_vsprintf_p(void)1483 static 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
test__get_output_format(void)1513 static 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
START_TEST(printf)1546 START_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 }
1564