ReactOS 0.4.16-dev-1408-gbc64f3a
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#define _CRT_NON_CONFORMING_SWPRINTFS
27
28#include <stdio.h>
29#include <errno.h>
30#include <math.h>
31#include <locale.h>
32
33#include "windef.h"
34#include "winbase.h"
35#include "winnls.h"
36
37#include "wine/test.h"
38
39static inline float __port_ind(void)
40{
41 static const unsigned __ind_bytes = 0xffc00000;
42 return *(const float *)&__ind_bytes;
43}
44#define IND __port_ind()
45
46static int (__cdecl *p__vscprintf)(const char *format, va_list valist);
47static int (__cdecl *p__vscwprintf)(const wchar_t *format, va_list valist);
48static int (__cdecl *p__vsnwprintf_s)(wchar_t *str, size_t sizeOfBuffer,
49 size_t count, const wchar_t *format,
50 va_list valist);
51static int (__cdecl *p__ecvt_s)(char *buffer, size_t length, double number,
52 int ndigits, int *decpt, int *sign);
53static int (__cdecl *p__fcvt_s)(char *buffer, size_t length, double number,
54 int ndigits, int *decpt, int *sign);
55static unsigned int (__cdecl *p__get_output_format)(void);
56static unsigned int (__cdecl *p__set_output_format)(unsigned int);
57static int (WINAPIV *p_sprintf)(char*, ...);
58static int (__cdecl *p__vsprintf_p)(char*, size_t, const char*, va_list);
59static int (__cdecl *p_vswprintf)(wchar_t *str, const wchar_t *format, va_list valist);
60static int (__cdecl *p__vswprintf)(wchar_t *str, const wchar_t *format, va_list valist);
61static int (__cdecl *p__vswprintf_l)(wchar_t *str, const wchar_t *format,
62 void *locale, va_list valist);
63static int (__cdecl *p__vswprintf_c)(wchar_t *str, size_t size, const wchar_t *format,
64 va_list valist);
65static int (__cdecl *p__vswprintf_c_l)(wchar_t *str, size_t size, const wchar_t *format,
66 void *locale, va_list valist);
67static int (__cdecl *p__vswprintf_p_l)(wchar_t *str, size_t size, const wchar_t *format,
68 void *locale, va_list valist);
69
70static void init( void )
71{
72 HMODULE hmod = GetModuleHandleA("msvcrt.dll");
73
74 p_sprintf = (void *)GetProcAddress(hmod, "sprintf");
75 p__vscprintf = (void *)GetProcAddress(hmod, "_vscprintf");
76 p__vscwprintf = (void *)GetProcAddress(hmod, "_vscwprintf");
77 p__vsnwprintf_s = (void *)GetProcAddress(hmod, "_vsnwprintf_s");
78 p__ecvt_s = (void *)GetProcAddress(hmod, "_ecvt_s");
79 p__fcvt_s = (void *)GetProcAddress(hmod, "_fcvt_s");
80 p__get_output_format = (void *)GetProcAddress(hmod, "_get_output_format");
81 p__set_output_format = (void *)GetProcAddress(hmod, "_set_output_format");
82 p__vsprintf_p = (void*)GetProcAddress(hmod, "_vsprintf_p");
83 p_vswprintf = (void*)GetProcAddress(hmod, "vswprintf");
84 p__vswprintf = (void*)GetProcAddress(hmod, "_vswprintf");
85 p__vswprintf_l = (void*)GetProcAddress(hmod, "_vswprintf_l");
86 p__vswprintf_c = (void*)GetProcAddress(hmod, "_vswprintf_c");
87 p__vswprintf_c_l = (void*)GetProcAddress(hmod, "_vswprintf_c_l");
88 p__vswprintf_p_l = (void*)GetProcAddress(hmod, "_vswprintf_p_l");
89}
90
91static void test_sprintf( void )
92{
93 enum {
94 NO_ARG,
95 INT_ARG,
96 ULONGLONG_ARG,
97 DOUBLE_ARG,
98 PTR_ARG,
99 TODO_FLAG = 0x1000
100 };
101
102 struct {
103 const char *format;
104 const char *out;
105 const char *broken;
106 int type;
107 int arg_i;
108 ULONGLONG arg_ull;
109 double arg_d;
110 const void *arg_ptr;
111 } tests[] = {
112 { "%+#23.15e", "+7.894561230000000e+008", 0, DOUBLE_ARG, 0, 0, 789456123 },
113 { "%-#23.15e", "7.894561230000000e+008 ", 0, DOUBLE_ARG, 0, 0, 789456123 },
114 { "%#23.15e", " 7.894561230000000e+008", 0, DOUBLE_ARG, 0, 0, 789456123 },
115 { "%#1.1g", "8.e+008", 0, DOUBLE_ARG, 0, 0, 789456123 },
116 { "%I64d", "-8589934591", 0, ULONGLONG_ARG, 0, ((ULONGLONG)0xffffffff)*0xffffffff },
117 { "%+8I64d", " +100", 0, ULONGLONG_ARG, 0, 100 },
118 { "%+.8I64d", "+00000100", 0, ULONGLONG_ARG, 0, 100 },
119 { "%+10.8I64d", " +00000100", 0, ULONGLONG_ARG, 0, 100 },
120 { "%_1I64d", "_1I64d", 0, ULONGLONG_ARG, 0, 100 },
121 { "%-1.5I64d", "-00100", 0, ULONGLONG_ARG, 0, -100 },
122 { "%5I64d", " 100", 0, ULONGLONG_ARG, 0, 100 },
123 { "%5I64d", " -100", 0, ULONGLONG_ARG, 0, -100 },
124 { "%-5I64d", "100 ", 0, ULONGLONG_ARG, 0, 100 },
125 { "%-5I64d", "-100 ", 0, ULONGLONG_ARG, 0, -100 },
126 { "%-.5I64d", "00100", 0, ULONGLONG_ARG, 0, 100 },
127 { "%-.5I64d", "-00100", 0, ULONGLONG_ARG, 0, -100 },
128 { "%-8.5I64d", "00100 ", 0, ULONGLONG_ARG, 0, 100 },
129 { "%-8.5I64d", "-00100 ", 0, ULONGLONG_ARG, 0, -100 },
130 { "%05I64d", "00100", 0, ULONGLONG_ARG, 0, 100 },
131 { "%05I64d", "-0100", 0, ULONGLONG_ARG, 0, -100 },
132 { "% I64d", " 100", 0, ULONGLONG_ARG, 0, 100 },
133 { "% I64d", "-100", 0, ULONGLONG_ARG, 0, -100 },
134 { "% 5I64d", " 100", 0, ULONGLONG_ARG, 0, 100 },
135 { "% 5I64d", " -100", 0, ULONGLONG_ARG, 0, -100 },
136 { "% .5I64d", " 00100", 0, ULONGLONG_ARG, 0, 100 },
137 { "% .5I64d", "-00100", 0, ULONGLONG_ARG, 0, -100 },
138 { "% 8.5I64d", " 00100", 0, ULONGLONG_ARG, 0, 100 },
139 { "% 8.5I64d", " -00100", 0, ULONGLONG_ARG, 0, -100 },
140 { "%.0I64d", "", 0, ULONGLONG_ARG },
141 { "%#+21.18I64x", " 0x00ffffffffffffff9c", 0, ULONGLONG_ARG, 0, -100 },
142 { "%#.25I64o", "0001777777777777777777634", 0, ULONGLONG_ARG, 0, -100 },
143 { "%#+24.20I64o", " 01777777777777777777634", 0, ULONGLONG_ARG, 0, -100 },
144 { "%#+18.21I64X", "0X00000FFFFFFFFFFFFFF9C", 0, ULONGLONG_ARG, 0, -100 },
145 { "%#+20.24I64o", "001777777777777777777634", 0, ULONGLONG_ARG, 0, -100 },
146 { "%#+25.22I64u", " 0018446744073709551615", 0, ULONGLONG_ARG, 0, -1 },
147 { "%#+25.22I64u", " 0018446744073709551615", 0, ULONGLONG_ARG, 0, -1 },
148 { "%#+30.25I64u", " 0000018446744073709551615", 0, ULONGLONG_ARG, 0, -1 },
149 { "%+#25.22I64d", " -0000000000000000000001", 0, ULONGLONG_ARG, 0, -1 },
150 { "%#-8.5I64o", "00144 ", 0, ULONGLONG_ARG, 0, 100 },
151 { "%#-+ 08.5I64d", "+00100 ", 0, ULONGLONG_ARG, 0, 100 },
152 { "%.80I64d",
153 "00000000000000000000000000000000000000000000000000000000000000000000000000000001",
154 0, ULONGLONG_ARG, 0, 1 },
155 { "% .80I64d",
156 " 00000000000000000000000000000000000000000000000000000000000000000000000000000001",
157 0, ULONGLONG_ARG, 0, 1 },
158 { "% .80d",
159 " 00000000000000000000000000000000000000000000000000000000000000000000000000000001",
160 0, INT_ARG, 1 },
161 { "%I", "I", 0, INT_ARG, 1 },
162 { "%Iq", "Iq", 0, INT_ARG, 1 },
163 { "%Ihd", "Ihd", 0, INT_ARG, 1 },
164 { "%I0d", "I0d", 0, INT_ARG, 1 },
165 { "%I64D", "D", 0, ULONGLONG_ARG, 0, -1 },
166 { "%zx", "1", "zx", INT_ARG, 1 },
167 { "%z", "z", 0, INT_ARG, 1 },
168 { "%tx", "1", "tx", INT_ARG, 1 },
169 { "%t", "t", 0, INT_ARG, 1 },
170 { "% d", " 1", 0, INT_ARG, 1 },
171 { "%+ d", "+1", 0, INT_ARG, 1 },
172 { "%S", "wide", 0, PTR_ARG, 0, 0, 0, L"wide" },
173 { "%04c", "0001", 0, INT_ARG, '1' },
174 { "%-04c", "1 ", 0, INT_ARG, '1' },
175 { "%#012x", "0x0000000001", 0, INT_ARG, 1 },
176 { "%#012x", "000000000000", 0, INT_ARG, 0 },
177 { "%#04.8x", "0x00000001", 0, INT_ARG, 1 },
178 { "%#04.8x", "00000000", 0, INT_ARG, 0 },
179 { "%#-08.2x", "0x01 ", 0, INT_ARG, 1 },
180 { "%#-08.2x", "00 ", 0, INT_ARG, 0 },
181 { "%#.0x", "0x1", 0, INT_ARG, 1 },
182 { "%#.0x", "", 0, INT_ARG, 0 },
183 { "%#08o", "00000001", 0, INT_ARG, 1 },
184 { "%#o", "01", 0, INT_ARG, 1 },
185 { "%#o", "0", 0, INT_ARG, 0 },
186 { "%04s", "0foo", 0, PTR_ARG, 0, 0, 0, "foo" },
187 { "%.1s", "f", 0, PTR_ARG, 0, 0, 0, "foo" },
188 { "hello", "hello", 0, NO_ARG },
189 { "%ws", "wide", 0, PTR_ARG, 0, 0, 0, L"wide" },
190 { "%-10ws", "wide ", 0, PTR_ARG, 0, 0, 0, L"wide" },
191 { "%10ws", " wide", 0, PTR_ARG, 0, 0, 0, L"wide" },
192 { "%#+ -03whlls", "wide", 0, PTR_ARG, 0, 0, 0, L"wide" },
193 { "%w0s", "0s", 0, PTR_ARG, 0, 0, 0, L"wide" },
194 { "%w-s", "-s", 0, PTR_ARG, 0, 0, 0, L"wide" },
195 { "%ls", "wide", 0, PTR_ARG, 0, 0, 0, L"wide" },
196 { "%Ls", "not wide", 0, PTR_ARG, 0, 0, 0, "not wide" },
197 { "%b", "b", 0, NO_ARG },
198 { "%3c", " a", 0, INT_ARG, 'a' },
199 { "%3d", "1234", 0, INT_ARG, 1234 },
200 { "%3h", "", 0, NO_ARG },
201 { "%k%m%q%r%t%v%y%z", "kmqrtvyz", 0, NO_ARG },
202 { "%-1d", "2", 0, INT_ARG, 2 },
203 { "%2.4f", "8.6000", 0, DOUBLE_ARG, 0, 0, 8.6 },
204 { "%0f", "0.600000", 0, DOUBLE_ARG, 0, 0, 0.6 },
205 { "%.0f", "1", 0, DOUBLE_ARG, 0, 0, 0.6 },
206 { "%2.4e", "8.6000e+000", 0, DOUBLE_ARG, 0, 0, 8.6 },
207 { "% 2.4e", " 8.6000e+000", 0, DOUBLE_ARG, 0, 0, 8.6 },
208 { "% 014.4e", " 008.6000e+000", 0, DOUBLE_ARG, 0, 0, 8.6 },
209 { "% 2.4e", "-8.6000e+000", 0, DOUBLE_ARG, 0, 0, -8.6 },
210 { "%+2.4e", "+8.6000e+000", 0, DOUBLE_ARG, 0, 0, 8.6 },
211 { "%2.4g", "8.6", 0, DOUBLE_ARG, 0, 0, 8.6 },
212 { "%-i", "-1", 0, INT_ARG, -1 },
213 { "%-i", "1", 0, INT_ARG, 1 },
214 { "%+i", "+1", 0, INT_ARG, 1 },
215 { "%o", "12", 0, INT_ARG, 10 },
216 { "%s", "(null)", 0, PTR_ARG, 0, 0, 0, NULL },
217 { "%s", "%%%%", 0, PTR_ARG, 0, 0, 0, "%%%%" },
218 { "%u", "4294967295", 0, INT_ARG, -1 },
219 { "%w", "", 0, INT_ARG, -1 },
220 { "%h", "", 0, INT_ARG, -1 },
221 { "%j", "", "j", ULONGLONG_ARG, 0, -1 },
222 { "%jd", "-1", "jd", ULONGLONG_ARG, 0, -1 },
223 { "%F", "", 0, INT_ARG, -1 },
224 { "%N", "", 0, INT_ARG, -1 },
225 { "%H", "H", 0, INT_ARG, -1 },
226 { "x%cx", "xXx", 0, INT_ARG, 0x100+'X' },
227 { "%%0", "%0", 0, NO_ARG },
228 { "%hx", "2345", 0, INT_ARG, 0x12345 },
229 { "%hhx", "123", 0, INT_ARG, 0x123 },
230 { "%hhx", "2345", 0, INT_ARG, 0x12345 },
231 { "%lf", "-1.#IND00", 0, DOUBLE_ARG, 0, 0, IND },
232 { "%lf", "1.#QNAN0", 0, DOUBLE_ARG, 0, 0, NAN },
233 { "%lf", "1.#INF00", 0, DOUBLE_ARG, 0, 0, INFINITY },
234 { "%le", "-1.#IND00e+000", 0, DOUBLE_ARG, 0, 0, IND },
235 { "%le", "1.#QNAN0e+000", 0, DOUBLE_ARG, 0, 0, NAN },
236 { "%le", "1.#INF00e+000", 0, DOUBLE_ARG, 0, 0, INFINITY },
237 { "%lg", "-1.#IND", 0, DOUBLE_ARG, 0, 0, IND },
238 { "%lg", "1.#QNAN", 0, DOUBLE_ARG, 0, 0, NAN },
239 { "%lg", "1.#INF", 0, DOUBLE_ARG, 0, 0, INFINITY },
240 { "%010.2lf", "-000001.#J", 0, DOUBLE_ARG, 0, 0, IND },
241 { "%010.2lf", "0000001.#R", 0, DOUBLE_ARG, 0, 0, NAN },
242 { "%010.2lf", "0000001.#J", 0, DOUBLE_ARG, 0, 0, INFINITY },
243 { "%c", "a", 0, INT_ARG, 'a' },
244 { "%c", "\x82", 0, INT_ARG, 0xa082 },
245 { "%C", "a", 0, INT_ARG, 'a' },
246 { "%C", "", 0, INT_ARG, 0x3042 },
247 { "a%Cb", "ab", 0, INT_ARG, 0x3042 },
248 { "%lld", "-8589934591", "1", ULONGLONG_ARG, 0, ((ULONGLONG)0xffffffff)*0xffffffff },
249 { "%I32d", "1", "I32d", INT_ARG, 1 },
250 { "%.0f", "-2", 0, DOUBLE_ARG, 0, 0, -1.5 },
251 { "%.0f", "-1", 0, DOUBLE_ARG, 0, 0, -0.5 },
252 { "%.0f", "1", 0, DOUBLE_ARG, 0, 0, 0.5 },
253 { "%.0f", "2", 0, DOUBLE_ARG, 0, 0, 1.5 },
254 { "%.30f", "0.333333333333333310000000000000", 0, TODO_FLAG | DOUBLE_ARG, 0, 0, 1.0/3.0 },
255 { "%.30lf", "1.414213562373095100000000000000", 0, TODO_FLAG | DOUBLE_ARG, 0, 0, sqrt(2) },
256 { "%f", "3.141593", 0, DOUBLE_ARG, 0, 0, 3.141592653590000 },
257 { "%.10f", "3.1415926536", 0, DOUBLE_ARG, 0, 0, 3.141592653590000 },
258 { "%.11f", "3.14159265359", 0, DOUBLE_ARG, 0, 0, 3.141592653590000 },
259 { "%.15f", "3.141592653590000", 0, DOUBLE_ARG, 0, 0, 3.141592653590000 },
260 { "%.15f", "3.141592653589793", 0, DOUBLE_ARG, 0, 0, M_PI },
261 { "%.13f", "37.8662615745371", 0, DOUBLE_ARG, 0, 0, 37.866261574537077 },
262 { "%.14f", "37.86626157453708", 0, DOUBLE_ARG, 0, 0, 37.866261574537077 },
263 { "%.15f", "37.866261574537077", 0, DOUBLE_ARG, 0, 0, 37.866261574537077 },
264 { "%g", "0.0005", 0, DOUBLE_ARG, 0, 0, 0.0005 },
265 { "%g", "5e-005", 0, DOUBLE_ARG, 0, 0, 0.00005 },
266 { "%g", "5e-006", 0, DOUBLE_ARG, 0, 0, 0.000005 },
267 { "%g", "1e+015", 0, DOUBLE_ARG, 0, 0, 999999999999999.0 },
268 { "%g", "1e+015", 0, DOUBLE_ARG, 0, 0, 1000000000000000.0 },
269 { "%.15g", "0.0005", 0, DOUBLE_ARG, 0, 0, 0.0005 },
270 { "%.15g", "5e-005", 0, DOUBLE_ARG, 0, 0, 0.00005 },
271 { "%.15g", "5e-006", 0, DOUBLE_ARG, 0, 0, 0.000005 },
272 { "%.15g", "999999999999999", 0, DOUBLE_ARG, 0, 0, 999999999999999.0 },
273 { "%.15g", "1e+015", 0, DOUBLE_ARG, 0, 0, 1000000000000000.0 },
274 };
275
276 char buffer[100];
277 int i, x, r;
278
279 for (i=0; i<ARRAY_SIZE(tests); i++) {
280 memset(buffer, 'x', sizeof(buffer));
281 switch(tests[i].type & 0xff) {
282 case NO_ARG:
283 r = p_sprintf(buffer, tests[i].format);
284 break;
285 case INT_ARG:
286 r = p_sprintf(buffer, tests[i].format, tests[i].arg_i);
287 break;
288 case ULONGLONG_ARG:
289 r = p_sprintf(buffer, tests[i].format, tests[i].arg_ull);
290 break;
291 case DOUBLE_ARG:
292 r = p_sprintf(buffer, tests[i].format, tests[i].arg_d);
293 break;
294 case PTR_ARG:
295 r = p_sprintf(buffer, tests[i].format, tests[i].arg_ptr);
296 break;
297 default:
298 ok(0, "tests[%d].type = %x\n", i, tests[i].type);
299 continue;
300 }
301
302 ok(r == strlen(buffer), "%d) r = %d, buffer = \"%s\"\n", i, r, buffer);
303 todo_wine_if(tests[i].type & TODO_FLAG)
304 {
305 ok(!strcmp(buffer, tests[i].out) ||
306 broken(tests[i].broken && !strcmp(buffer, tests[i].broken)),
307 "%d) buffer = \"%s\"\n", i, buffer);
308 }
309 }
310
311 if (sizeof(void *) == 8)
312 {
313 r = p_sprintf(buffer, "%p", (void *)57);
314 ok(!strcmp(buffer,"0000000000000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
315 ok( r==16, "return count wrong\n");
316
317 r = p_sprintf(buffer, "%#020p", (void *)57);
318 ok(!strcmp(buffer," 0X0000000000000039"),"Pointer formatted incorrectly\n");
319 ok( r==20, "return count wrong\n");
320
321 r = p_sprintf(buffer, "%Fp", (void *)57);
322 ok(!strcmp(buffer,"0000000000000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
323 ok( r==16, "return count wrong\n");
324
325 r = p_sprintf(buffer, "%Np", (void *)57);
326 ok(!strcmp(buffer,"0000000000000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
327 ok( r==16, "return count wrong\n");
328
329 r = p_sprintf(buffer, "%#-020p", (void *)57);
330 ok(!strcmp(buffer,"0X0000000000000039 "),"Pointer formatted incorrectly\n");
331 ok( r==20, "return count wrong\n");
332
333 r = p_sprintf(buffer, "%Ix %d", (size_t)0x12345678123456,1);
334 ok(!strcmp(buffer,"12345678123456 1"),"buffer = %s\n",buffer);
335 ok( r==16, "return count wrong\n");
336
337 r = p_sprintf(buffer, "%p", 0);
338 ok(!strcmp(buffer,"0000000000000000"), "failed\n");
339 ok( r==16, "return count wrong\n");
340 }
341 else
342 {
343 r = p_sprintf(buffer, "%p", (void *)57);
344 ok(!strcmp(buffer,"00000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
345 ok( r==8, "return count wrong\n");
346
347 r = p_sprintf(buffer, "%#012p", (void *)57);
348 ok(!strcmp(buffer," 0X00000039"),"Pointer formatted incorrectly\n");
349 ok( r==12, "return count wrong\n");
350
351 r = p_sprintf(buffer, "%Fp", (void *)57);
352 ok(!strcmp(buffer,"00000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
353 ok( r==8, "return count wrong\n");
354
355 r = p_sprintf(buffer, "%Np",(void *)57);
356 ok(!strcmp(buffer,"00000039"),"Pointer formatted incorrectly \"%s\"\n",buffer);
357 ok( r==8, "return count wrong\n");
358
359 r = p_sprintf(buffer, "%#-012p", (void *)57);
360 ok(!strcmp(buffer,"0X00000039 "),"Pointer formatted incorrectly\n");
361 ok( r==12, "return count wrong\n");
362
363 r = p_sprintf(buffer, "%Ix %d", 0x123456, 1);
364 ok(!strcmp(buffer,"123456 1"),"buffer = %s\n",buffer);
365 ok( r==8, "return count wrong\n");
366
367 r = p_sprintf(buffer, "%p", 0);
368 ok(!strcmp(buffer,"00000000"), "failed\n");
369 ok( r==8, "return count wrong\n");
370 }
371
372 r = p_sprintf(buffer, "%.*s", 1, "foo");
373 ok(!strcmp(buffer,"f"),"Precision ignored \"%s\"\n",buffer);
374 ok( r==1, "return count wrong\n");
375
376 r = p_sprintf(buffer, "%*s", -5, "foo");
377 ok(!strcmp(buffer,"foo "),"Negative field width ignored \"%s\"\n",buffer);
378 ok( r==5, "return count wrong\n");
379
380 x = 0;
381 r = p_sprintf(buffer, "asdf%n", &x );
382 if (r == -1)
383 {
384 /* %n format is disabled by default on vista */
385 /* FIXME: should test with _set_printf_count_output */
386 ok(x == 0, "should not write to x: %d\n", x);
387 }
388 else
389 {
390 ok(x == 4, "should write to x: %d\n", x);
391 ok(!strcmp(buffer,"asdf"), "failed\n");
392 ok( r==4, "return count wrong: %d\n", r);
393 }
394
395 r = p_sprintf(buffer, "%S", L"\x3042");
396 ok(r==-1 || broken(!r), "r = %d\n", r);
397
398 if(!setlocale(LC_ALL, "Japanese_Japan.932")) {
399 win_skip("Japanese_Japan.932 locale not available\n");
400 return;
401 }
402
403 r = p_sprintf(buffer, "%c", 0xa082);
404 ok(r==1, "r = %d\n", r);
405 ok(!strcmp(buffer, "\x82"), "failed: \"%s\"\n", buffer);
406
407 r = p_sprintf(buffer, "%C", 0x3042);
408 ok(r==2, "r = %d\n", r);
409 ok(!strcmp(buffer, "\x82\xa0"), "failed: \"%s\"\n", buffer);
410
411 strcpy(buffer, " string to copy");
412 r = p_sprintf(buffer, buffer+1);
413 ok(r==14, "r = %d\n", r);
414 ok(!strcmp(buffer, "string to copy"), "failed: \"%s\"\n", buffer);
415
416 setlocale(LC_ALL, "C");
417
418 r = p_sprintf(buffer, "%*1d", 1, 3);
419 ok(r==11, "r = %d\n", r);
420 ok(!strcmp(buffer, " 3"), "failed: \"%s\"\n", buffer);
421
422 r = p_sprintf(buffer, "%0*0d", 1, 2);
423 ok(r==10, "r = %d\n", r);
424 ok(!strcmp(buffer, "0000000002"), "failed: \"%s\"\n", buffer);
425
426 r = p_sprintf(buffer, "% *2d", 0, 7);
427 ok(r==2, "r = %d\n", r);
428 ok(!strcmp(buffer, " 7"), "failed: \"%s\"\n", buffer);
429}
430
431static void test_swprintf( void )
432{
433 wchar_t buffer[100];
434 double pnumber = 789456123;
435 const char string[] = "string";
436
437 swprintf(buffer, L"%+#23.15e", pnumber);
438 ok(wcsstr(buffer, L"e+008") != 0, "Sprintf different\n");
439 swprintf(buffer, L"%I64d", ((ULONGLONG)0xffffffff)*0xffffffff);
440 ok(wcslen(buffer) == 11, "Problem with long long\n");
441 swprintf(buffer, L"%S", string);
442 ok(wcslen(buffer) == 6, "Problem with \"%%S\" interpretation\n");
443 swprintf(buffer, L"%hs", string);
444 ok(!wcscmp(L"string", buffer), "swprintf failed with %%hs\n");
445}
446
447static void test_snprintf (void)
448{
449 struct snprintf_test {
450 const char *format;
451 int expected;
452 };
453 /* Pre-2.1 libc behaviour, not C99 compliant. */
454 const struct snprintf_test tests[] = {{"short", 5},
455 {"justfit", 7},
456 {"justfits", 8},
457 {"muchlonger", -1}};
458 char buffer[8];
459 const int bufsiz = sizeof buffer;
460 unsigned int i;
461
462 int (__cdecl *p_snprintf)(char*,size_t,const char*,...) = _snprintf;
463
464 for (i = 0; i < ARRAY_SIZE(tests); i++) {
465 const char *fmt = tests[i].format;
466 const int expect = tests[i].expected;
467 const int n = p_snprintf(buffer, bufsiz, fmt);
468 const int valid = n < 0 ? bufsiz : (n == bufsiz ? n : n+1);
469
470 ok (n == expect, "\"%s\": expected %d, returned %d\n",
471 fmt, expect, n);
472 ok (!memcmp (fmt, buffer, valid),
473 "\"%s\": rendered \"%.*s\"\n", fmt, valid, buffer);
474 }
475}
476
477static void test_fprintf(void)
478{
479 FILE *fp = fopen("fprintf.tst", "wb");
480 char buf[1024];
481 int ret;
482
483 ret = fprintf(fp, "simple test\n");
484 ok(ret == 12, "ret = %d\n", ret);
485 ret = ftell(fp);
486 ok(ret == 12, "ftell returned %d\n", ret);
487
488 ret = fprintf(fp, "contains%cnull\n", '\0');
489 ok(ret == 14, "ret = %d\n", ret);
490 ret = ftell(fp);
491 ok(ret == 26, "ftell returned %d\n", ret);
492
493 ret = fwprintf(fp, L"unicode\n");
494 ok(ret == 8, "ret = %d\n", ret);
495 ret = ftell(fp);
496 ok(ret == 42, "ftell returned %d\n", ret);
497
498 fclose(fp);
499
500 fp = fopen("fprintf.tst", "rb");
501 ret = fscanf(fp, "%[^\n] ", buf);
502 ok(ret == 1, "ret = %d\n", ret);
503 ret = ftell(fp);
504 ok(ret == 12, "ftell returned %d\n", ret);
505 ok(!strcmp(buf, "simple test"), "buf = %s\n", buf);
506
507 fgets(buf, sizeof(buf), fp);
508 ret = ftell(fp);
509 ok(ret == 26, "ret = %d\n", ret);
510 ok(!memcmp(buf, "contains\0null\n", 14), "buf = %s\n", buf);
511
512 memset(buf, 0, sizeof(buf));
513 fgets(buf, sizeof(buf), fp);
514 ret = ftell(fp);
515 ok(ret == 41, "ret = %d\n", ret);
516 ok(!wcscmp((wchar_t*)buf, L"unicode\n"), "buf = %s\n", wine_dbgstr_w((WCHAR*)buf));
517
518 fclose(fp);
519
520 fp = fopen("fprintf.tst", "wt");
521
522 ret = fprintf(fp, "simple test\n");
523 ok(ret == 12, "ret = %d\n", ret);
524 ret = ftell(fp);
525 ok(ret == 13, "ftell returned %d\n", ret);
526
527 ret = fprintf(fp, "contains%cnull\n", '\0');
528 ok(ret == 14, "ret = %d\n", ret);
529 ret = ftell(fp);
530 ok(ret == 28, "ftell returned %d\n", ret);
531
532 ret = fwprintf(fp, L"unicode\n");
533 ok(ret == 8, "ret = %d\n", ret);
534 ret = ftell(fp);
535 ok(ret == 37, "ftell returned %d\n", ret);
536
537 fclose(fp);
538
539 fp = fopen("fprintf.tst", "rb");
540 ret = fscanf(fp, "%[^\n] ", buf);
541 ok(ret == 1, "ret = %d\n", ret);
542 ret = ftell(fp);
543 ok(ret == 13, "ftell returned %d\n", ret);
544 ok(!strcmp(buf, "simple test\r"), "buf = %s\n", buf);
545
546 fgets(buf, sizeof(buf), fp);
547 ret = ftell(fp);
548 ok(ret == 28, "ret = %d\n", ret);
549 ok(!memcmp(buf, "contains\0null\r\n", 15), "buf = %s\n", buf);
550
551 fgets(buf, sizeof(buf), fp);
552 ret = ftell(fp);
553 ok(ret == 37, "ret = %d\n", ret);
554 ok(!strcmp(buf, "unicode\r\n"), "buf = %s\n", buf);
555
556 fclose(fp);
557 unlink("fprintf.tst");
558}
559
560static void test_fcvt(void)
561{
562 char *str;
563 int dec=100, sign=100;
564
565 /* Numbers less than 1.0 with different precisions */
566 str = _fcvt(0.0001, 1, &dec, &sign );
567 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
568 ok( -3 == dec, "dec wrong %d\n", dec);
569 ok( 0 == sign, "sign wrong\n");
570
571 str = _fcvt(0.0001, -10, &dec, &sign );
572 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
573 ok( -3 == dec, "dec wrong %d\n", dec);
574 ok( 0 == sign, "sign wrong\n");
575
576 str = _fcvt(0.0001, 10, &dec, &sign );
577 ok( 0 == strcmp(str,"1000000"), "bad return '%s'\n", str);
578 ok( -3 == dec, "dec wrong %d\n", dec);
579 ok( 0 == sign, "sign wrong\n");
580
581 /* Basic sign test */
582 str = _fcvt(-111.0001, 5, &dec, &sign );
583 ok( 0 == strcmp(str,"11100010"), "bad return '%s'\n", str);
584 ok( 3 == dec, "dec wrong %d\n", dec);
585 ok( 1 == sign, "sign wrong\n");
586
587 str = _fcvt(111.0001, 5, &dec, &sign );
588 ok( 0 == strcmp(str,"11100010"), "bad return '%s'\n", str);
589 ok( 3 == dec, "dec wrong\n");
590 ok( 0 == sign, "sign wrong\n");
591
592 /* 0.0 with different precisions */
593 str = _fcvt(0.0, 5, &dec, &sign );
594 ok( 0 == strcmp(str,"00000"), "bad return '%s'\n", str);
595 ok( 0 == dec, "dec wrong %d\n", dec);
596 ok( 0 == sign, "sign wrong\n");
597
598 str = _fcvt(0.0, 0, &dec, &sign );
599 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
600 ok( 0 == dec, "dec wrong %d\n", dec);
601 ok( 0 == sign, "sign wrong\n");
602
603 str = _fcvt(0.0, -1, &dec, &sign );
604 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
605 ok( 0 == dec, "dec wrong %d\n", dec);
606 ok( 0 == sign, "sign wrong\n");
607
608 /* Numbers > 1.0 with 0 or -ve precision */
609 str = _fcvt(-123.0001, 0, &dec, &sign );
610 ok( 0 == strcmp(str,"123"), "bad return '%s'\n", str);
611 ok( 3 == dec, "dec wrong %d\n", dec);
612 ok( 1 == sign, "sign wrong\n");
613
614 str = _fcvt(-123.0001, -1, &dec, &sign );
615 ok( 0 == strcmp(str,"12"), "bad return '%s'\n", str);
616 ok( 3 == dec, "dec wrong %d\n", dec);
617 ok( 1 == sign, "sign wrong\n");
618
619 str = _fcvt(-123.0001, -2, &dec, &sign );
620 ok( 0 == strcmp(str,"1"), "bad return '%s'\n", str);
621 ok( 3 == dec, "dec wrong %d\n", dec);
622 ok( 1 == sign, "sign wrong\n");
623
624 str = _fcvt(-123.0001, -3, &dec, &sign );
625 ok( 0 == strcmp(str,""), "bad return '%s'\n", str);
626 ok( 3 == dec, "dec wrong %d\n", dec);
627 ok( 1 == sign, "sign wrong\n");
628
629 /* Numbers > 1.0, but with rounding at the point of precision */
630 str = _fcvt(99.99, 1, &dec, &sign );
631 ok( 0 == strcmp(str,"1000"), "bad return '%s'\n", str);
632 ok( 3 == dec, "dec wrong %d\n", dec);
633 ok( 0 == sign, "sign wrong\n");
634
635 /* Numbers < 1.0 where rounding occurs at the point of precision */
636 str = _fcvt(0.00636, 2, &dec, &sign );
637 ok( 0 == strcmp(str,"1"), "bad return '%s'\n", str);
638 ok( -1 == dec, "dec wrong %d\n", dec);
639 ok( 0 == sign, "sign wrong\n");
640
641 str = _fcvt(0.00636, 3, &dec, &sign );
642 ok( 0 == strcmp(str,"6"), "bad return '%s'\n", str);
643 ok( -2 == dec, "dec wrong %d\n", dec);
644 ok( 0 == sign, "sign wrong\n");
645
646 str = _fcvt(0.09999999996, 2, &dec, &sign );
647 ok( 0 == strcmp(str,"10"), "bad return '%s'\n", str);
648 ok( 0 == dec, "dec wrong %d\n", dec);
649 ok( 0 == sign, "sign wrong\n");
650
651 str = _fcvt(0.6, 0, &dec, &sign );
652 ok( 0 == strcmp(str,"1"), "bad return '%s'\n", str);
653 ok( 1 == dec, "dec wrong %d\n", dec);
654 ok( 0 == sign, "sign wrong\n");
655}
656
657/* Don't test nrdigits < 0, msvcrt on Win9x and NT4 will corrupt memory by
658 * writing outside allocated memory */
659static struct {
660 double value;
661 int nrdigits;
662 const char *expstr_e;
663 const char *expstr_f;
664 int expdecpt_e;
665 int expdecpt_f;
666 int expsign;
667} test_cvt_testcases[] = {
668 { 45.0, 2, "45", "4500", 2, 2, 0 },
669 { 0.0001, 1, "1", "", -3, -3, 0 },
670 { 0.0001, 10,"1000000000", "1000000", -3, -3, 0 },
671 { -111.0001, 5, "11100", "11100010", 3, 3, 1 },
672 { 111.0001, 5, "11100", "11100010", 3, 3, 0 },
673 { 3333.3, 2, "33", "333330", 4, 4, 0 },
674 {999999999999.9, 3, "100","999999999999900", 13, 12, 0 },
675 { 0.0, 5, "00000", "00000", 0, 0, 0 },
676 { 0.0, 0, "", "", 0, 0, 0 },
677 { 0.0, -1, "", "", 0, 0, 0 },
678 { -0.0, 5, "00000", "00000", 0, 0, 1 },
679 { -0.0, 0, "", "", 0, 0, 1 },
680 { -0.0, -1, "", "", 0, 0, 1 },
681 { -123.0001, 0, "", "123", 3, 3, 1 },
682 { -123.0001, -1, "", "12", 3, 3, 1 },
683 { -123.0001, -2, "", "1", 3, 3, 1 },
684 { -123.0001, -3, "", "", 3, 3, 1 },
685 { 99.99, 1, "1", "1000", 3, 3, 0 },
686 { 0.0063, 2, "63", "1", -2, -1, 0 },
687 { 0.0063, 3, "630", "6", -2, -2, 0 },
688 { 0.09999999996, 2, "10", "10", 0, 0, 0 },
689 { 0.6, 1, "6", "6", 0, 0, 0 },
690 { 0.6, 0, "", "1", 1, 1, 0 },
691 { 0.4, 0, "", "", 0, 0, 0 },
692 { 0.49, 0, "", "", 0, 0, 0 },
693 { 0.51, 0, "", "1", 1, 1, 0 },
694 { NAN, 2, "1$", "1#R", 1, 1, 0 },
695 { NAN, 5, "1#QNB", "1#QNAN", 1, 1, 0 },
696 { -NAN, 2, "1$", "1#J", 1, 1, 1 },
697 { -NAN, 5, "1#IND", "1#IND0", 1, 1, 1 },
698 { INFINITY, 2, "1$", "1#J", 1, 1, 0 },
699 { INFINITY, 5, "1#INF", "1#INF0", 1, 1, 0 },
700 { -INFINITY, 2, "1$", "1#J", 1, 1, 1 },
701 { -INFINITY, 5, "1#INF", "1#INF0", 1, 1, 1 },
702 { 1.0, 30, "100000000000000000000000000000",
703 "1000000000000000000000000000000", 1, 1, 0},
704 { 123456789012345678901.0, 30, "123456789012345680000000000000",
705 "123456789012345680000000000000000000000000000000000", 21, 21, 0},
706 { 0, 0, "END"}
707};
708
709static void test_xcvt(void)
710{
711 char *str;
712 int i, decpt, sign, err;
713
714 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
715 decpt = sign = 100;
716 str = _ecvt( test_cvt_testcases[i].value,
717 test_cvt_testcases[i].nrdigits,
718 &decpt,
719 &sign);
720 ok( !strncmp( str, test_cvt_testcases[i].expstr_e, 15),
721 "%d) _ecvt() bad return, got '%s' expected '%s'\n", i, str,
722 test_cvt_testcases[i].expstr_e);
723 ok( decpt == test_cvt_testcases[i].expdecpt_e,
724 "%d) _ecvt() decimal point wrong, got %d expected %d\n", i, decpt,
725 test_cvt_testcases[i].expdecpt_e);
726#ifdef __REACTOS__
727 if (((i == 10) || (i == 11) || (i == 12)) && (_winver < 0x600))
728 {
729 skip("broken on win 2003\n");
730 continue;
731 }
732#endif // __REACTOS__
733 ok( sign == test_cvt_testcases[i].expsign,
734 "%d) _ecvt() sign wrong, got %d expected %d\n", i, sign,
735 test_cvt_testcases[i].expsign);
736 }
737 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
738 decpt = sign = 100;
739 str = _fcvt( test_cvt_testcases[i].value,
740 test_cvt_testcases[i].nrdigits,
741 &decpt,
742 &sign);
743 ok( !strncmp( str, test_cvt_testcases[i].expstr_f, 15),
744 "%d) _fcvt() bad return, got '%s' expected '%s'\n", i, str,
745 test_cvt_testcases[i].expstr_f);
746 ok( decpt == test_cvt_testcases[i].expdecpt_f,
747 "%d) _fcvt() decimal point wrong, got %d expected %d\n", i, decpt,
748 test_cvt_testcases[i].expdecpt_f);
749#ifdef __REACTOS__
750 if (((i == 10) || (i == 11) || (i == 12)) && (_winver < 0x600))
751 {
752 skip("broken on win 2003\n");
753 continue;
754 }
755#endif // __REACTOS__
756 ok( sign == test_cvt_testcases[i].expsign,
757 "%d) _fcvt() sign wrong, got %d expected %d\n", i, sign,
758 test_cvt_testcases[i].expsign);
759 }
760
761 if (p__ecvt_s)
762 {
763 str = malloc(1024);
764 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
765 decpt = sign = 100;
766 err = p__ecvt_s(str, 1024, test_cvt_testcases[i].value, test_cvt_testcases[i].nrdigits, &decpt, &sign);
767 ok(err == 0, "_ecvt_s() failed with error code %d\n", err);
768 ok( !strncmp( str, test_cvt_testcases[i].expstr_e, 15),
769 "%d) _ecvt_s() bad return, got '%s' expected '%s'\n", i, str,
770 test_cvt_testcases[i].expstr_e);
771 ok( decpt == test_cvt_testcases[i].expdecpt_e,
772 "%d) _ecvt_s() decimal point wrong, got %d expected %d\n", i, decpt,
773 test_cvt_testcases[i].expdecpt_e);
774 ok( sign == test_cvt_testcases[i].expsign,
775 "%d) _ecvt_s() sign wrong, got %d expected %d\n", i, sign,
776 test_cvt_testcases[i].expsign);
777 }
778 free(str);
779 }
780 else
781 win_skip("_ecvt_s not available\n");
782
783 if (p__fcvt_s)
784 {
785 int i;
786
787 str = malloc(1024);
788
789 /* invalid arguments */
790 err = p__fcvt_s(NULL, 0, 0.0, 0, &i, &i);
791 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
792
793 err = p__fcvt_s(str, 0, 0.0, 0, &i, &i);
794 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
795
796 str[0] = ' ';
797 str[1] = 0;
798 err = p__fcvt_s(str, -1, 0.0, 0, &i, &i);
799 ok(err == 0, "got %d, expected 0\n", err);
800 ok(str[0] == 0, "got %c, expected 0\n", str[0]);
801 ok(str[1] == 0, "got %c, expected 0\n", str[1]);
802
803 err = p__fcvt_s(str, 1, 0.0, 0, NULL, &i);
804 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
805
806 err = p__fcvt_s(str, 1, 0.0, 0, &i, NULL);
807 ok(err == EINVAL, "got %d, expected EINVAL\n", err);
808
809 for( i = 0; strcmp( test_cvt_testcases[i].expstr_e, "END"); i++){
810 decpt = sign = 100;
811 err = p__fcvt_s(str, 1024, test_cvt_testcases[i].value, test_cvt_testcases[i].nrdigits, &decpt, &sign);
812 ok(!err, "%d) _fcvt_s() failed with error code %d\n", i, err);
813 ok( !strncmp( str, test_cvt_testcases[i].expstr_f, 15),
814 "%d) _fcvt_s() bad return, got '%s' expected '%s'. test %d\n", i, str,
815 test_cvt_testcases[i].expstr_f, i);
816 ok( decpt == test_cvt_testcases[i].expdecpt_f,
817 "%d) _fcvt_s() decimal point wrong, got %d expected %d\n", i, decpt,
818 test_cvt_testcases[i].expdecpt_f);
819 ok( sign == test_cvt_testcases[i].expsign,
820 "%d) _fcvt_s() sign wrong, got %d expected %d\n", i, sign,
821 test_cvt_testcases[i].expsign);
822 }
823 free(str);
824 }
825 else
826 win_skip("_fcvt_s not available\n");
827}
828
829static int WINAPIV _vsnwprintf_wrapper(wchar_t *str, size_t len, const wchar_t *format, ...)
830{
831 int ret;
832 va_list valist;
833 va_start(valist, format);
834 ret = _vsnwprintf(str, len, format, valist);
835 va_end(valist);
836 return ret;
837}
838
839static void test_vsnwprintf(void)
840{
841 int ret;
842 wchar_t str[32];
843 char buf[32];
844
845 ret = _vsnwprintf_wrapper( str, ARRAY_SIZE(str), L"%ws%ws%ws", L"one", L"two", L"three" );
846 ok( ret == 11, "got %d expected 11\n", ret );
847 WideCharToMultiByte( CP_ACP, 0, str, -1, buf, sizeof(buf), NULL, NULL );
848 ok( !strcmp(buf, "onetwothree"), "got %s expected 'onetwothree'\n", buf );
849
850 ret = _vsnwprintf_wrapper( str, 0, L"%ws%ws%ws", L"one", L"two", L"three" );
851 ok( ret == -1, "got %d, expected -1\n", ret );
852
853 ret = _vsnwprintf_wrapper( NULL, 0, L"%ws%ws%ws", L"one", L"two", L"three" );
854 ok( ret == 11 || broken(ret == -1 /* Win2k */), "got %d, expected 11\n", ret );
855}
856
857static int WINAPIV vswprintf_wrapper(wchar_t *str, const wchar_t *format, ...)
858{
859 int ret;
860 va_list valist;
861 va_start(valist, format);
862 ret = p_vswprintf(str, format, valist);
863 va_end(valist);
864 return ret;
865}
866
867static int WINAPIV _vswprintf_wrapper(wchar_t *str, const wchar_t *format, ...)
868{
869 int ret;
870 va_list valist;
871 va_start(valist, format);
872 ret = p__vswprintf(str, format, valist);
873 va_end(valist);
874 return ret;
875}
876
877static int WINAPIV _vswprintf_l_wrapper(wchar_t *str, const wchar_t *format, void *locale, ...)
878{
879 int ret;
880 va_list valist;
881 va_start(valist, locale);
882 ret = p__vswprintf_l(str, format, locale, valist);
883 va_end(valist);
884 return ret;
885}
886
887static int WINAPIV _vswprintf_c_wrapper(wchar_t *str, size_t size, const wchar_t *format, ...)
888{
889 int ret;
890 va_list valist;
891 va_start(valist, format);
892 ret = p__vswprintf_c(str, size, format, valist);
893 va_end(valist);
894 return ret;
895}
896
897static int WINAPIV _vswprintf_c_l_wrapper(wchar_t *str, size_t size, const wchar_t *format, void *locale, ...)
898{
899 int ret;
900 va_list valist;
901 va_start(valist, locale);
902 ret = p__vswprintf_c_l(str, size, format, locale, valist);
903 va_end(valist);
904 return ret;
905}
906
907static int WINAPIV _vswprintf_p_l_wrapper(wchar_t *str, size_t size, const wchar_t *format, void *locale, ...)
908{
909 int ret;
910 va_list valist;
911 va_start(valist, locale);
912 ret = p__vswprintf_p_l(str, size, format, locale, valist);
913 va_end(valist);
914 return ret;
915}
916
917static void test_vswprintf(void)
918{
919 wchar_t buf[20];
920 int ret;
921
922 if (!p_vswprintf || !p__vswprintf || !p__vswprintf_l ||!p__vswprintf_c
923 || !p__vswprintf_c_l || !p__vswprintf_p_l)
924 {
925 win_skip("_vswprintf or vswprintf not available\n");
926 return;
927 }
928
929 ret = vswprintf_wrapper(buf, L"%s %d", L"number", 123);
930 ok(ret == 10, "got %d, expected 10\n", ret);
931 ok(!wcscmp(buf, L"number 123"), "buf = %s\n", wine_dbgstr_w(buf));
932
933 memset(buf, 0, sizeof(buf));
934 ret = _vswprintf_wrapper(buf, L"%s %d", L"number", 123);
935 ok(ret == 10, "got %d, expected 10\n", ret);
936 ok(!wcscmp(buf, L"number 123"), "buf = %s\n", wine_dbgstr_w(buf));
937
938 memset(buf, 0, sizeof(buf));
939 ret = _vswprintf_l_wrapper(buf, L"%s %d", NULL, L"number", 123);
940 ok(ret == 10, "got %d, expected 10\n", ret);
941 ok(!wcscmp(buf, L"number 123"), "buf = %s\n", wine_dbgstr_w(buf));
942
943 memset(buf, 0, sizeof(buf));
944 ret = _vswprintf_c_wrapper(buf, 20, L"%s %d", L"number", 123);
945 ok(ret == 10, "got %d, expected 10\n", ret);
946 ok(!wcscmp(buf, L"number 123"), "buf = %s\n", wine_dbgstr_w(buf));
947
948 memset(buf, 'x', sizeof(buf));
949 ret = _vswprintf_c_wrapper(buf, 10, L"%s %d", L"number", 123);
950 ok(ret == -1, "got %d, expected -1\n", ret);
951 ok(!wcscmp(buf, L"number 12"), "buf = %s\n", wine_dbgstr_w(buf));
952
953 memset(buf, 0, sizeof(buf));
954 ret = _vswprintf_c_l_wrapper(buf, 20, L"%s %d", NULL, L"number", 123);
955 ok(ret == 10, "got %d, expected 10\n", ret);
956 ok(!wcscmp(buf, L"number 123"), "buf = %s\n", wine_dbgstr_w(buf));
957
958 memset(buf, 0, sizeof(buf));
959 ret = _vswprintf_p_l_wrapper(buf, 20, L"%s %d", NULL, L"number", 123);
960 ok(ret == 10, "got %d, expected 10\n", ret);
961 ok(!wcscmp(buf, L"number 123"), "buf = %s\n", wine_dbgstr_w(buf));
962}
963
964static int WINAPIV _vscprintf_wrapper(const char *format, ...)
965{
966 int ret;
967 va_list valist;
968 va_start(valist, format);
969 ret = p__vscprintf(format, valist);
970 va_end(valist);
971 return ret;
972}
973
974static void test_vscprintf(void)
975{
976 int ret;
977
978 if (!p__vscprintf)
979 {
980 win_skip("_vscprintf not available\n");
981 return;
982 }
983
984 ret = _vscprintf_wrapper( "%s %d", "number", 1 );
985 ok( ret == 8, "got %d expected 8\n", ret );
986}
987
988static int WINAPIV _vscwprintf_wrapper(const wchar_t *format, ...)
989{
990 int ret;
991 va_list valist;
992 va_start(valist, format);
993 ret = p__vscwprintf(format, valist);
994 va_end(valist);
995 return ret;
996}
997
998static void test_vscwprintf(void)
999{
1000 int ret;
1001
1002 if (!p__vscwprintf)
1003 {
1004 win_skip("_vscwprintf not available\n");
1005 return;
1006 }
1007
1008 ret = _vscwprintf_wrapper(L"%s %d", L"number", 1 );
1009 ok( ret == 8, "got %d expected 8\n", ret );
1010}
1011
1012static int WINAPIV _vsnwprintf_s_wrapper(wchar_t *str, size_t sizeOfBuffer,
1013 size_t count, const wchar_t *format, ...)
1014{
1015 int ret;
1016 va_list valist;
1017 va_start(valist, format);
1018 ret = p__vsnwprintf_s(str, sizeOfBuffer, count, format, valist);
1019 va_end(valist);
1020 return ret;
1021}
1022
1023static void test_vsnwprintf_s(void)
1024{
1025 wchar_t buffer[14] = { 0 };
1026 int ret;
1027
1028 if (!p__vsnwprintf_s)
1029 {
1030 win_skip("_vsnwprintf_s not available\n");
1031 return;
1032 }
1033
1034 /* Enough room. */
1035 ret = _vsnwprintf_s_wrapper(buffer, 14, _TRUNCATE, L"AB%uC", 123);
1036 ok( ret == 6, "length wrong, expect=6, got=%d\n", ret);
1037 ok( !wcscmp(L"AB123C", buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1038
1039 ret = _vsnwprintf_s_wrapper(buffer, 12, _TRUNCATE, L"AB%uC", 123);
1040 ok( ret == 6, "length wrong, expect=6, got=%d\n", ret);
1041 ok( !wcscmp(L"AB123C", buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1042
1043 ret = _vsnwprintf_s_wrapper(buffer, 7, _TRUNCATE, L"AB%uC", 123);
1044 ok( ret == 6, "length wrong, expect=6, got=%d\n", ret);
1045 ok( !wcscmp(L"AB123C", buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1046
1047 /* Not enough room. */
1048 ret = _vsnwprintf_s_wrapper(buffer, 6, _TRUNCATE, L"AB%uC", 123);
1049 ok( ret == -1, "length wrong, expect=-1, got=%d\n", ret);
1050 ok( !wcscmp(L"AB123", buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1051
1052 ret = _vsnwprintf_s_wrapper(buffer, 2, _TRUNCATE, L"AB%uC", 123);
1053 ok( ret == -1, "length wrong, expect=-1, got=%d\n", ret);
1054 ok( !wcscmp(L"A", buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1055
1056 ret = _vsnwprintf_s_wrapper(buffer, 1, _TRUNCATE, L"AB%uC", 123);
1057 ok( ret == -1, "length wrong, expect=-1, got=%d\n", ret);
1058 ok( !wcscmp(L"", buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
1059}
1060
1061static int WINAPIV _vsprintf_p_wrapper(char *str, size_t sizeOfBuffer,
1062 const char *format, ...)
1063{
1064 int ret;
1065 va_list valist;
1066 va_start(valist, format);
1067 ret = p__vsprintf_p(str, sizeOfBuffer, format, valist);
1068 va_end(valist);
1069 return ret;
1070}
1071
1072static void test_vsprintf_p(void)
1073{
1074 char buf[1024];
1075 int ret;
1076
1077 if(!p__vsprintf_p) {
1078 win_skip("vsprintf_p not available\n");
1079 return;
1080 }
1081
1082 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%s %d", "test", 1234);
1083 ok(ret == 9, "ret = %d\n", ret);
1084 ok(!memcmp(buf, "test 1234", 10), "buf = %s\n", buf);
1085
1086 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%1$d", 1234, "additional param");
1087 ok(ret == 4, "ret = %d\n", ret);
1088 ok(!memcmp(buf, "1234", 5), "buf = %s\n", buf);
1089
1090 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%2$s %1$d", 1234, "test");
1091 ok(ret == 9, "ret = %d\n", ret);
1092 ok(!memcmp(buf, "test 1234", 10), "buf = %s\n", buf);
1093
1094 ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%2$*3$s %2$.*1$s", 2, "test", 3);
1095 ok(ret == 7, "ret = %d\n", ret);
1096 ok(!memcmp(buf, "test te", 8), "buf = %s\n", buf);
1097
1098 /* Following test invokes invalid parameter handler */
1099 /* ret = _vsprintf_p_wrapper(buf, sizeof(buf), "%d %1$d", 1234); */
1100}
1101
1102static void test__get_output_format(void)
1103{
1104 unsigned int ret;
1105 char buf[64];
1106 int c;
1107
1108 if (!p__get_output_format || !p__set_output_format)
1109 {
1110 win_skip("_get_output_format or _set_output_format is not available\n");
1111 return;
1112 }
1113
1114 ret = p__get_output_format();
1115 ok(ret == 0, "got %d\n", ret);
1116
1117 c = p_sprintf(buf, "%E", 1.23);
1118 ok(c == 13, "c = %d\n", c);
1119 ok(!strcmp(buf, "1.230000E+000"), "buf = %s\n", buf);
1120
1121 ret = p__set_output_format(_TWO_DIGIT_EXPONENT);
1122 ok(ret == 0, "got %d\n", ret);
1123
1124 c = p_sprintf(buf, "%E", 1.23);
1125 ok(c == 12, "c = %d\n", c);
1126 ok(!strcmp(buf, "1.230000E+00"), "buf = %s\n", buf);
1127
1128 ret = p__get_output_format();
1129 ok(ret == _TWO_DIGIT_EXPONENT, "got %d\n", ret);
1130
1131 ret = p__set_output_format(_TWO_DIGIT_EXPONENT);
1132 ok(ret == _TWO_DIGIT_EXPONENT, "got %d\n", ret);
1133}
1134
1135START_TEST(printf)
1136{
1137 init();
1138
1139 test_sprintf();
1140 test_swprintf();
1141 test_snprintf();
1142 test_fprintf();
1143 test_fcvt();
1144 test_xcvt();
1145 test_vsnwprintf();
1146 test_vscprintf();
1147 test_vscwprintf();
1148 test_vswprintf();
1149 test_vsnwprintf_s();
1150 test_vsprintf_p();
1151 test__get_output_format();
1152}
expect
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
sqrt
_STLP_DECLSPEC complex< float > _STLP_CALL sqrt(const complex< float > &)
Definition: complex.cpp:188
dec
ios_base &_STLP_CALL dec(ios_base &__s)
Definition: _ios_base.h:321
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
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
strncmp
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
__cdecl
#define __cdecl
Definition: accygwin.h:79
va_list
char * va_list
Definition: acmsvcex.h:78
va_end
#define va_end(ap)
Definition: acmsvcex.h:90
va_start
#define va_start(ap, A)
Definition: acmsvcex.h:91
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
broken
#define broken(x)
Definition: atltest.h:178
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
locale
Definition: _locale.h:75
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
ret
return ret
Definition: mutex.c:146
L
#define L(x)
Definition: resources.c:13
printf
#define printf
Definition: freeldr.h:97
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
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
n
GLdouble n
Definition: glext.h:7729
buffer
GLuint buffer
Definition: glext.h:5915
size
GLsizeiptr size
Definition: glext.h:5919
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
LC_ALL
#define LC_ALL
Definition: locale.h:17
INFINITY
#define INFINITY
Definition: math.h:56
_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)
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
M_PI
#define M_PI
Definition: macros.h:263
tests
static struct test_info tests[]
hmod
static PEXPLICIT_ACCESSW *static HMODULE hmod
Definition: security.c:143
expected
BOOL expected
Definition: store.c:2063
NAN
#define NAN
Definition: mesh.c:39
todo_wine_if
#define todo_wine_if(is_todo)
Definition: custom.c:86
_vsnwprintf_wrapper
static int WINAPIV _vsnwprintf_wrapper(wchar_t *str, size_t len, const wchar_t *format,...)
Definition: printf.c:829
size_t
static static size_t
Definition: printf.c:58
test_vsnwprintf_s
static void test_vsnwprintf_s(void)
Definition: printf.c:1023
expstr_f
const char * expstr_f
Definition: printf.c:663
test_vsnwprintf
static void test_vsnwprintf(void)
Definition: printf.c:839
_vscwprintf_wrapper
static int WINAPIV _vscwprintf_wrapper(const wchar_t *format,...)
Definition: printf.c:988
init
static void init(void)
Definition: printf.c:70
vswprintf_wrapper
static int WINAPIV vswprintf_wrapper(wchar_t *str, const wchar_t *format,...)
Definition: printf.c:857
valist
static va_list valist
Definition: printf.c:46
test_swprintf
static void test_swprintf(void)
Definition: printf.c:431
locale
static const wchar_t void * locale
Definition: printf.c:62
_vsprintf_p_wrapper
static int WINAPIV _vsprintf_p_wrapper(char *str, size_t sizeOfBuffer, const char *format,...)
Definition: printf.c:1061
expstr_e
const char * expstr_e
Definition: printf.c:662
test_cvt_testcases
static struct @1814 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:907
test_sprintf
static void test_sprintf(void)
Definition: printf.c:91
_vswprintf_l_wrapper
static int WINAPIV _vswprintf_l_wrapper(wchar_t *str, const wchar_t *format, void *locale,...)
Definition: printf.c:877
__port_ind
static float __port_ind(void)
Definition: printf.c:39
test__get_output_format
static void test__get_output_format(void)
Definition: printf.c:1102
count
static size_t size_t count
Definition: printf.c:49
expdecpt_e
int expdecpt_e
Definition: printf.c:664
test_vsprintf_p
static void test_vsprintf_p(void)
Definition: printf.c:1072
expdecpt_f
int expdecpt_f
Definition: printf.c:665
sizeOfBuffer
static size_t sizeOfBuffer
Definition: printf.c:48
format
static size_t size_t const wchar_t * format
Definition: printf.c:49
nrdigits
int nrdigits
Definition: printf.c:661
IND
#define IND
Definition: printf.c:44
va_list
static static const char va_list
Definition: printf.c:58
test_vscprintf
static void test_vscprintf(void)
Definition: printf.c:974
size
static size_t size
Definition: printf.c:63
test_fprintf
static void test_fprintf(void)
Definition: printf.c:477
sign
static size_t double int int int * sign
Definition: printf.c:52
_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:1012
_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:897
test_snprintf
static void test_snprintf(void)
Definition: printf.c:447
_vswprintf_wrapper
static int WINAPIV _vswprintf_wrapper(wchar_t *str, const wchar_t *format,...)
Definition: printf.c:867
test_vscwprintf
static void test_vscwprintf(void)
Definition: printf.c:998
ndigits
static size_t double int ndigits
Definition: printf.c:52
test_vswprintf
static void test_vswprintf(void)
Definition: printf.c:917
decpt
static size_t double int int * decpt
Definition: printf.c:52
number
static size_t double number
Definition: printf.c:51
expsign
int expsign
Definition: printf.c:666
_vswprintf_c_wrapper
static int WINAPIV _vswprintf_c_wrapper(wchar_t *str, size_t size, const wchar_t *format,...)
Definition: printf.c:887
length
static size_t length
Definition: printf.c:51
test_fcvt
static void test_fcvt(void)
Definition: printf.c:560
_vscprintf_wrapper
static int WINAPIV _vscprintf_wrapper(const char *format,...)
Definition: printf.c:964
test_xcvt
static void test_xcvt(void)
Definition: printf.c:709
_winver
unsigned int _winver
Definition: environ.c:14
err
#define err(...)
Definition: reactos_support_code.h:30
str
const WCHAR * str
Definition: rpc_transport.c:2724
WINAPIV
#define WINAPIV
Definition: sdbpapi.h:64
_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)
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:164
strcpy
strcpy
Definition: string.h:131
memset
#define memset(x, y, z)
Definition: compat.h:39
_iobuf
Definition: mbstring.h:19
fmt
Definition: dsound.c:943
format
Definition: format.c:58
setlocale
#define setlocale(n, s)
Definition: locale.h:46
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
_TRUNCATE
#define _TRUNCATE
Definition: corecrt.h:278
value
Definition: pdh_main.c:96
out
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
_snprintf
#define _snprintf
Definition: xmlstorage.h:200