?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32: Handle some escape sequences with FORMAT_MESSAGE_IGNORE_INSERTS in FormatMe...
[wine/hacks.git] / dlls / kernel32 / tests / format_msg.c
blob1bf11880639cd740b756c0efccfa9f6476188b6d
1 /* Unit test suite for FormatMessageA/W
2 *
3 * Copyright 2002 Mike McCormack for CodeWeavers
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <stdarg.h>
21
22 #include "wine/test.h"
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winnls.h"
26
27 static DWORD __cdecl doit(DWORD flags, LPCVOID src, DWORD msg_id, DWORD lang_id,
28 LPSTR out, DWORD outsize, ... )
29 {
30 __ms_va_list list;
31 DWORD r;
32
33 __ms_va_start(list, outsize);
34 r = FormatMessageA(flags, src, msg_id,
35 lang_id, out, outsize, &list);
36 __ms_va_end(list);
37 return r;
38 }
39
40 static DWORD __cdecl doitW(DWORD flags, LPCVOID src, DWORD msg_id, DWORD lang_id,
41 LPWSTR out, DWORD outsize, ... )
42 {
43 __ms_va_list list;
44 DWORD r;
45
46 __ms_va_start(list, outsize);
47 r = FormatMessageW(flags, src, msg_id,
48 lang_id, out, outsize, &list);
49 __ms_va_end(list);
50 return r;
51 }
52
53 static void test_message_from_string_wide(void)
54 {
55 static const WCHAR test[] = {'t','e','s','t',0};
56 static const WCHAR empty[] = {0};
57 static const WCHAR te[] = {'t','e',0};
58 static const WCHAR st[] = {'s','t',0};
59 static const WCHAR t[] = {'t',0};
60 static const WCHAR e[] = {'e',0};
61 static const WCHAR s[] = {'s',0};
62 static const WCHAR fmt_null[] = {'%',0};
63 static const WCHAR fmt_tnull[] = {'t','e','s','t','%',0};
64 static const WCHAR fmt_1[] = {'%','1',0};
65 static const WCHAR fmt_12[] = {'%','1','%','2',0};
66 static const WCHAR fmt_123[] = {'%','1','%','3','%','2','%','1',0};
67 static const WCHAR fmt_123c[] = {'%','1','!','c','!','%','2','!','c','!','%','3','!','c','!','%','1','!','c','!',0};
68 static const WCHAR fmt_123lc[] = {'%','1','!','l','c','!','%','2','!','l','c','!','%','3','!','l','c','!','%','1','!','l','c','!',0};
69 static const WCHAR fmt_123wc[] = {'%','1','!','w','c','!','%','2','!','w','c','!','%','3','!','w','c','!','%','1','!','w','c','!',0};
70 static const WCHAR fmt_123C[] = {'%','1','!','C','!','%','2','!','C','!','%','3','!','C','!','%','1','!','C','!',0};
71 static const WCHAR fmt_123d[] = {'%','1','!','d','!','%','2','!','d','!','%','3','!','d','!',0};
72 static const WCHAR fmt_1s[] = {'%','1','!','s','!',0};
73 static const WCHAR fmt_s[] = {'%','!','s','!',0};
74 static const WCHAR fmt_ls[] = {'%','!','l','s','!',0};
75 static const WCHAR fmt_ws[] = {'%','!','w','s','!',0};
76 static const WCHAR fmt_S[] = {'%','!','S','!',0};
77 static const WCHAR fmt_14d[] = {'%','1','!','4','d','!',0};
78 static const WCHAR fmt_14x[] = {'%','1','!','4','x','!',0};
79 static const WCHAR fmt_14X[] = {'%','1','!','4','X','!',0};
80 static const WCHAR fmt_1_4X[] = {'%','1','!','-','4','X','!',0};
81 static const WCHAR fmt_1_4d[] = {'%','1','!','-','4','d','!',0};
82 static const WCHAR fmt_2pct[] = {' ','%','%','%','%',' ',0};
83 static const WCHAR fmt_2dot1d[] = {' ', '%','.','%','.',' ',' ','%','1','!','d','!',0};
84 static const WCHAR fmt_t0t[] = {'t','e','s','t','%','0','t','e','s','t',0};
85 static const WCHAR fmt_yah[] = {'y','a','h','%','!','%','0',' ',' ',' ',0};
86 static const WCHAR fmt_space[] = {'%',' ','%',' ',' ',' ',0};
87 static const WCHAR fmt_hi_lf[] = {'h','i','\n',0};
88 static const WCHAR fmt_hi_crlf[] = {'h','i','\r','\n',0};
89 static const WCHAR fmt_cr[] = {'\r',0};
90 static const WCHAR fmt_crcrlf[] = {'\r','\r','\n',0};
91 static const WCHAR fmt_13s[] = {'%','1','!','3','s','!',0};
92 static const WCHAR fmt_1os[] = {'%','1','!','*','s','!',0};
93 static const WCHAR fmt_142u[] = {'%','1','!','4','.','2','u','!',0};
94 static const WCHAR fmt_1oou[] = {'%','1','!','*','.','*','u','!',0};
95 static const WCHAR fmt_1oou1oou[] = {'%','1','!','*','.','*','u','!',',','%','1','!','*','.','*','u','!',0};
96 static const WCHAR fmt_1oou3oou[] = {'%','1','!','*','.','*','u','!',',','%','3','!','*','.','*','u','!',0};
97 static const WCHAR fmt_1oou4oou[] = {'%','1','!','*','.','*','u','!',',','%','4','!','*','.','*','u','!',0};
98
99 static const WCHAR s_123d[] = {'1','2','3',0};
100 static const WCHAR s_14d[] = {' ',' ',' ','1',0};
101 static const WCHAR s_14x[] = {' ',' ',' ','b',0};
102 static const WCHAR s_14X[] = {' ',' ',' ','B',0};
103 static const WCHAR s_1_4X[] = {'B',' ',' ',' ',0};
104 static const WCHAR s_14d2[] = {' ',' ','1','1',0};
105 static const WCHAR s_1_4d[] = {'1',' ',' ',' ',0};
106 static const WCHAR s_1AB[] = {' ','1','A','B',0};
107 static const WCHAR s_2pct[] = {' ','%','%',' ',0};
108 static const WCHAR s_2dot147[] = {' ','.','.',' ',' ','4','2','7',0};
109 static const WCHAR s_yah[] = {'y','a','h','!',0};
110 static const WCHAR s_space[] = {' ',' ',' ',' ',0};
111 static const WCHAR s_hi_crlf[] = {'h','i','\r','\n',0};
112 static const WCHAR s_crlf[] = {'\r','\n',0};
113 static const WCHAR s_crlfcrlf[] = {'\r','\n','\r','\n',0};
114 static const WCHAR s_hi_sp[] = {'h','i',' ',0};
115 static const WCHAR s_sp[] = {' ',0};
116 static const WCHAR s_2sp[] = {' ',' ',0};
117 static const WCHAR s_spt[] = {' ',' ','t',0};
118 static const WCHAR s_sp3t[] = {' ',' ',' ','t',0};
119 static const WCHAR s_sp03[] = {' ',' ','0','3',0};
120 static const WCHAR s_sp001[] = {' ',' ','0','0','1',0};
121 static const WCHAR s_sp001002[] = {' ',' ','0','0','1',',',' ','0','0','0','2',0};
122 static const WCHAR s_sp001sp002[] = {' ',' ','0','0','1',',',' ',' ','0','0','0','2',0};
123 static const WCHAR s_sp002sp001[] = {' ',' ','0','0','0','2',',',' ',' ','0','0','1',0};
124 static const WCHAR s_sp002sp003[] = {' ',' ','0','0','0','2',',',' ','0','0','0','0','3',0};
125 static const WCHAR s_sp001004[] = {' ',' ','0','0','1',',','0','0','0','0','0','4',0};
126
127 static const WCHAR init_buf[] = {'x', 'x', 'x', 'x', 'x', 'x'};
128 static const WCHAR broken_buf[] = {'t','e','s','t','x','x'};
129
130 WCHAR out[0x100] = {0};
131 DWORD r, error;
132
133 SetLastError(0xdeadbeef);
134 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
135 error = GetLastError();
136 if (!r && error == ERROR_CALL_NOT_IMPLEMENTED)
137 {
138 win_skip("FormatMessageW is not implemented\n");
139 return;
140 }
141
142 /* the basics */
143 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0,
144 0, out, sizeof(out)/sizeof(WCHAR), NULL);
145 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
146 ok(r==4, "failed: r=%d\n", r);
147
148 /* null string, crashes on Windows */
149 if (0)
150 {
151 SetLastError(0xdeadbeef);
152 memcpy(out, init_buf, sizeof(init_buf));
153 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0,
154 0, out, sizeof(out)/sizeof(WCHAR), NULL);
155 }
156
157 /* empty string */
158 SetLastError(0xdeadbeef);
159 memcpy(out, init_buf, sizeof(init_buf));
160 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, empty, 0,
161 0, out, sizeof(out)/sizeof(WCHAR), NULL);
162 error = GetLastError();
163 ok(!lstrcmpW(empty, out), "failed out=%s\n", wine_dbgstr_w(out));
164 ok(r==0, "succeeded: r=%d\n", r);
165 ok(error==0xdeadbeef, "last error %u\n", error);
166
167 /* format placeholder with no specifier */
168 SetLastError(0xdeadbeef);
169 memcpy(out, init_buf, sizeof(init_buf));
170 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, fmt_null, 0,
171 0, out, sizeof(out)/sizeof(WCHAR), NULL);
172 error = GetLastError();
173 ok(!memcmp(out, init_buf, sizeof(init_buf)),
174 "Expected the buffer to be unchanged\n");
175 ok(r==0, "succeeded: r=%d\n", r);
176 ok(error==ERROR_INVALID_PARAMETER, "last error %u\n", error);
177
178 /* test string with format placeholder with no specifier */
179 SetLastError(0xdeadbeef);
180 memcpy(out, init_buf, sizeof(init_buf));
181 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, fmt_tnull, 0,
182 0, out, sizeof(out)/sizeof(WCHAR), NULL);
183 error = GetLastError();
184 ok(!memcmp(out, init_buf, sizeof(init_buf)) ||
185 broken(!memcmp(out, broken_buf, sizeof(broken_buf))), /* W2K3+ */
186 "Expected the buffer to be unchanged\n");
187 ok(r==0, "succeeded: r=%d\n", r);
188 ok(error==ERROR_INVALID_PARAMETER, "last error %u\n", error);
189
190 /* using the format feature */
191 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1s, 0,
192 0, out, sizeof(out)/sizeof(WCHAR), test);
193 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
194 ok(r==4,"failed: r=%d\n", r);
195
196 /* no format */
197 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1, 0,
198 0, out, sizeof(out)/sizeof(WCHAR), test);
199 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
200 ok(r==4,"failed: r=%d\n", r);
201
202 /* two pieces */
203 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_12, 0,
204 0, out, sizeof(out)/sizeof(WCHAR), te, st);
205 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
206 ok(r==4,"failed: r=%d\n", r);
207
208 /* three pieces */
209 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123, 0,
210 0, out, sizeof(out)/sizeof(WCHAR), t, s, e);
211 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
212 ok(r==4,"failed: r=%d\n", r);
213
214 /* s doesn't seem to work in format strings */
215 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_s, 0,
216 0, out, sizeof(out)/sizeof(WCHAR), test);
217 ok(!lstrcmpW(&fmt_s[1], out), "failed out=%s\n", wine_dbgstr_w(out));
218 ok(r==3, "failed: r=%d\n", r);
219
220 /* nor ls */
221 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_ls, 0,
222 0, out, sizeof(out)/sizeof(WCHAR), test);
223 ok(!lstrcmpW(&fmt_ls[1], out), "failed out=%s\n", wine_dbgstr_w(out));
224 ok(r==4, "failed: r=%d\n", r);
225
226 /* nor S */
227 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_S, 0,
228 0, out, sizeof(out)/sizeof(WCHAR), test);
229 ok(!lstrcmpW(&fmt_S[1], out), "failed out=%s\n", wine_dbgstr_w(out));
230 ok(r==3, "failed: r=%d\n", r);
231
232 /* nor ws */
233 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_ws, 0,
234 0, out, sizeof(out)/sizeof(WCHAR), test);
235 ok(!lstrcmpW(&fmt_ws[1], out), "failed out=%s\n", wine_dbgstr_w(out));
236 ok(r==4, "failed: r=%d\n", r);
237
238 /* as characters */
239 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123c, 0,
240 0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
241 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
242 ok(r==4,"failed: r=%d\n", r);
243
244 /* lc is unicode */
245 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123lc, 0,
246 0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
247 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
248 ok(r==4,"failed: r=%d\n", r);
249
250 /* wc is unicode */
251 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123wc, 0,
252 0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
253 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
254 ok(r==4,"failed: r=%d\n", r);
255
256 /* C is unicode */
257 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123C, 0,
258 0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
259 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
260 ok(r==4,"failed: r=%d\n", r);
261
262 /* some numbers */
263 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123d, 0,
264 0, out, sizeof(out)/sizeof(WCHAR), 1, 2, 3);
265 ok(!lstrcmpW(s_123d, out), "failed out=%s\n", wine_dbgstr_w(out));
266 ok(r==3,"failed: r=%d\n", r);
267
268 /* a single digit with some spacing */
269 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14d, 0,
270 0, out, sizeof(out)/sizeof(WCHAR), 1);
271 ok(!lstrcmpW(s_14d, out), "failed out=%s\n", wine_dbgstr_w(out));
272
273 /* a single digit, left justified */
274 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1_4d, 0,
275 0, out, sizeof(out)/sizeof(CHAR), 1);
276 ok(!lstrcmpW(s_1_4d, out), "failed out=%s\n", wine_dbgstr_w(out));
277 ok(r==4,"failed: r=%d\n", r);
278
279 /* two digit decimal number */
280 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14d, 0,
281 0, out, sizeof(out)/sizeof(WCHAR), 11);
282 ok(!lstrcmpW(s_14d2, out), "failed out=%s\n", wine_dbgstr_w(out));
283 ok(r==4,"failed: r=%d\n", r);
284
285 /* a hex number */
286 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14x, 0,
287 0, out, sizeof(out)/sizeof(WCHAR), 11);
288 ok(!lstrcmpW(s_14x, out), "failed out=%s\n", wine_dbgstr_w(out));
289 ok(r==4,"failed: r=%d\n", r);
290
291 /* a hex number, upper case */
292 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14X, 0,
293 0, out, sizeof(out)/sizeof(WCHAR), 11);
294 ok(!lstrcmpW(s_14X, out), "failed out=%s\n", wine_dbgstr_w(out));
295 ok(r==4,"failed: r=%d\n", r);
296
297 /* a hex number, upper case, left justified */
298 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1_4X, 0,
299 0, out, sizeof(out)/sizeof(WCHAR), 11);
300 ok(!lstrcmpW(s_1_4X, out), "failed out=%s\n", wine_dbgstr_w(out));
301 ok(r==4,"failed: r=%d\n", r);
302
303 /* a long hex number, upper case */
304 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14X, 0,
305 0, out, sizeof(out)/sizeof(WCHAR), 0x1ab);
306 ok(!lstrcmpW(s_1AB, out), "failed out=%s\n", wine_dbgstr_w(out));
307 ok(r==4,"failed: r=%d\n", r);
308
309 /* two percent... */
310 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_2pct, 0,
311 0, out, sizeof(out)/sizeof(WCHAR));
312 ok(!lstrcmpW(s_2pct, out), "failed out=%s\n", wine_dbgstr_w(out));
313 ok(r==4,"failed: r=%d\n", r);
314
315 /* periods are special cases */
316 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_2dot1d, 0,
317 0, out, sizeof(out)/sizeof(WCHAR), 0x1ab);
318 ok(!lstrcmpW(s_2dot147, out), "failed out=%s\n", wine_dbgstr_w(out));
319 ok(r==8,"failed: r=%d\n", r);
320
321 /* %0 ends the line */
322 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_t0t, 0,
323 0, out, sizeof(out)/sizeof(WCHAR));
324 ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
325 ok(r==4,"failed: r=%d\n", r);
326
327 /* %! prints an exclamation */
328 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_yah, 0,
329 0, out, sizeof(out)/sizeof(WCHAR));
330 ok(!lstrcmpW(s_yah, out), "failed out=%s\n", wine_dbgstr_w(out));
331 ok(r==4,"failed: r=%d\n", r);
332
333 /* %space */
334 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_space, 0,
335 0, out, sizeof(out)/sizeof(WCHAR));
336 ok(!lstrcmpW(s_space, out), "failed out=%s\n", wine_dbgstr_w(out));
337 ok(r==4,"failed: r=%d\n", r);
338
339 /* line feed */
340 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_hi_lf, 0,
341 0, out, sizeof(out)/sizeof(WCHAR));
342 ok(!lstrcmpW(s_hi_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
343 ok(r==4,"failed: r=%d\n", r);
344
345 /* carriage return line feed */
346 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_hi_crlf, 0,
347 0, out, sizeof(out)/sizeof(WCHAR));
348 ok(!lstrcmpW(s_hi_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
349 ok(r==4,"failed: r=%d\n", r);
350
351 /* carriage return */
352 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_cr, 0,
353 0, out, sizeof(out)/sizeof(WCHAR));
354 ok(!lstrcmpW(s_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
355 ok(r==2,"failed: r=%d\n", r);
356
357 /* double carriage return line feed */
358 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_crcrlf, 0,
359 0, out, sizeof(out)/sizeof(WCHAR));
360 ok(!lstrcmpW(s_crlfcrlf, out), "failed out=%s\n", wine_dbgstr_w(out));
361 ok(r==4,"failed: r=%d\n", r);
362
363 /* precision and width */
364
365 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_13s,
366 0, 0, out, sizeof(out)/sizeof(WCHAR), t );
367 ok(!lstrcmpW(s_spt, out),"failed out=[%s]\n", wine_dbgstr_w(out));
368 ok(r==3, "failed: r=%d\n",r);
369 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1os,
370 0, 0, out, sizeof(out)/sizeof(WCHAR), 4, t );
371 ok(!lstrcmpW( s_sp3t, out),"failed out=[%s]\n", wine_dbgstr_w(out));
372 ok(r==4,"failed: r=%d\n",r);
373 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_142u,
374 0, 0, out, sizeof(out)/sizeof(WCHAR), 3 );
375 ok(!lstrcmpW( s_sp03, out),"failed out=[%s]\n", wine_dbgstr_w(out));
376 ok(r==4,"failed: r=%d\n",r);
377 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1oou,
378 0, 0, out, sizeof(out)/sizeof(WCHAR), 5, 3, 1 );
379 ok(!lstrcmpW( s_sp001, out),"failed out=[%s]\n", wine_dbgstr_w(out));
380 ok(r==5,"failed: r=%d\n",r);
381 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1oou1oou,
382 0, 0, out, sizeof(out)/sizeof(WCHAR), 5, 3, 1, 4, 2 );
383 ok(!lstrcmpW( s_sp001002, out),"failed out=[%s]\n", wine_dbgstr_w(out));
384 ok(r==11,"failed: r=%d\n",r);
385 r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1oou3oou,
386 0, 0, out, sizeof(out)/sizeof(WCHAR), 5, 3, 1, 6, 4, 2 );
387 ok(!lstrcmpW( s_sp001sp002, out) || broken(!lstrcmpW(s_sp001004, out)),
388 "failed out=[%s]\n", wine_dbgstr_w(out));
389 ok(r==12,"failed: r=%d\n",r);
390 /* args are not counted the same way with an argument array */
391 {
392 ULONG_PTR args[] = { 6, 4, 2, 5, 3, 1 };
393 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, fmt_1oou1oou,
394 0, 0, out, sizeof(out)/sizeof(WCHAR), (__ms_va_list *)args );
395 ok(!lstrcmpW(s_sp002sp003, out),"failed out=[%s]\n", wine_dbgstr_w(out));
396 ok(r==13,"failed: r=%d\n",r);
397 r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, fmt_1oou4oou,
398 0, 0, out, sizeof(out)/sizeof(WCHAR), (__ms_va_list *)args );
399 ok(!lstrcmpW(s_sp002sp001, out),"failed out=[%s]\n", wine_dbgstr_w(out));
400 ok(r==12,"failed: r=%d\n",r);
401 }
402
403 /* change of pace... test the low byte of dwflags */
404
405 /* line feed */
406 r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_hi_lf, 0,
407 0, out, sizeof(out)/sizeof(WCHAR));
408 ok(!lstrcmpW(s_hi_sp, out) || !lstrcmpW(s_hi_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
409 ok(r==3 || r==4,"failed: r=%d\n", r);
410
411 /* carriage return line feed */
412 r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_hi_crlf, 0,
413 0, out, sizeof(out)/sizeof(WCHAR));
414 ok(!lstrcmpW(s_hi_sp, out), "failed out=%s\n", wine_dbgstr_w(out));
415 ok(r==3,"failed: r=%d\n", r);
416
417 /* carriage return */
418 r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_cr, 0,
419 0, out, sizeof(out)/sizeof(WCHAR));
420 ok(!lstrcmpW(s_sp, out), "failed out=%s\n", wine_dbgstr_w(out));
421 ok(r==1,"failed: r=%d\n", r);
422
423 /* double carriage return line feed */
424 r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_crcrlf, 0,
425 0, out, sizeof(out)/sizeof(WCHAR));
426 ok(!lstrcmpW(s_2sp, out), "failed out=%s\n", wine_dbgstr_w(out));
427 ok(r==2,"failed: r=%d\n", r);
428 }
429
430 static void test_message_from_string(void)
431 {
432 CHAR out[0x100] = {0};
433 DWORD r;
434 static const char init_buf[] = {'x', 'x', 'x', 'x', 'x', 'x'};
435 static const WCHAR szwTest[] = { 't','e','s','t',0};
436
437 /* the basics */
438 r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0,
439 0, out, sizeof(out)/sizeof(CHAR),NULL);
440 ok(!strcmp("test", out),"failed out=[%s]\n",out);
441 ok(r==4,"failed: r=%d\n",r);
442
443 /* null string, crashes on Windows */
444 if (0)
445 {
446 SetLastError(0xdeadbeef);
447 memcpy(out, init_buf, sizeof(init_buf));
448 r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, NULL, 0,
449 0, out, sizeof(out)/sizeof(CHAR), NULL);
450 }
451
452 /* empty string */
453 SetLastError(0xdeadbeef);
454 memcpy(out, init_buf, sizeof(init_buf));
455 r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "", 0,
456 0, out, sizeof(out)/sizeof(CHAR), NULL);
457 ok(!memcmp(out, init_buf, sizeof(init_buf)) ||
458 broken(!strcmp("", out)), /* Win9x */
459 "Expected the buffer to be untouched\n");
460 ok(r==0, "succeeded: r=%d\n", r);
461 ok(GetLastError()==0xdeadbeef,
462 "last error %u\n", GetLastError());
463
464 /* format placeholder with no specifier */
465 SetLastError(0xdeadbeef);
466 memcpy(out, init_buf, sizeof(init_buf));
467 r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "%", 0,
468 0, out, sizeof(out)/sizeof(CHAR), NULL);
469 ok(!memcmp(out, init_buf, sizeof(init_buf)),
470 "Expected the buffer to be untouched\n");
471 ok(r==0, "succeeded: r=%d\n", r);
472 ok(GetLastError()==ERROR_INVALID_PARAMETER,
473 "last error %u\n", GetLastError());
474
475 /* test string with format placeholder with no specifier */
476 SetLastError(0xdeadbeef);
477 memcpy(out, init_buf, sizeof(init_buf));
478 r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test%", 0,
479 0, out, sizeof(out)/sizeof(CHAR), NULL);
480 ok(!memcmp(out, init_buf, sizeof(init_buf)),
481 "Expected the buffer to be untouched\n");
482 ok(r==0, "succeeded: r=%d\n", r);
483 ok(GetLastError()==ERROR_INVALID_PARAMETER,
484 "last error %u\n", GetLastError());
485
486 /* using the format feature */
487 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!s!", 0,
488 0, out, sizeof(out)/sizeof(CHAR), "test");
489 ok(!strcmp("test", out),"failed out=[%s]\n",out);
490 ok(r==4,"failed: r=%d\n",r);
491
492 /* no format */
493 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1", 0,
494 0, out, sizeof(out)/sizeof(CHAR), "test");
495 ok(!strcmp("test", out),"failed out=[%s]\n",out);
496 ok(r==4,"failed: r=%d\n",r);
497
498 /* two pieces */
499 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1%2", 0,
500 0, out, sizeof(out)/sizeof(CHAR), "te","st");
501 ok(!strcmp("test", out),"failed out=[%s]\n",out);
502 ok(r==4,"failed: r=%d\n",r);
503
504 /* three pieces */
505 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1%3%2%1", 0,
506 0, out, sizeof(out)/sizeof(CHAR), "t","s","e");
507 ok(!strcmp("test", out),"failed out=[%s]\n",out);
508 ok(r==4,"failed: r=%d\n",r);
509
510 /* s doesn't seem to work in format strings */
511 r = doit(FORMAT_MESSAGE_FROM_STRING, "%!s!", 0,
512 0, out, sizeof(out)/sizeof(CHAR), "test");
513 ok(!strcmp("!s!", out),"failed out=[%s]\n",out);
514 ok(r==3,"failed: r=%d\n",r);
515
516 /* ls is unicode */
517 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!ls!", 0,
518 0, out, sizeof(out)/sizeof(CHAR), szwTest);
519 ok(!strcmp("test", out),"failed out=[%s]\n",out);
520 ok(r==4,"failed: r=%d\n",r);
521
522 /* S is unicode */
523 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!S!", 0,
524 0, out, sizeof(out)/sizeof(CHAR), szwTest);
525 ok(!strcmp("test", out),"failed out=[%s]\n",out);
526 ok(r==4,"failed: r=%d\n",r);
527
528 /* ws is unicode */
529 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!ws!", 0,
530 0, out, sizeof(out)/sizeof(CHAR), szwTest);
531 ok(!strcmp("test", out),"failed out=[%s]\n",out);
532 ok(r==4,"failed: r=%d\n",r);
533
534 /* as characters */
535 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!c!%2!c!%3!c!%1!c!", 0,
536 0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
537 ok(!strcmp("test", out),"failed out=[%s]\n",out);
538 ok(r==4,"failed: r=%d\n",r);
539
540 /* lc is unicode */
541 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!lc!%2!lc!%3!lc!%1!lc!", 0,
542 0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
543 ok(!strcmp("test", out),"failed out=[%s]\n",out);
544 ok(r==4,"failed: r=%d\n",r);
545
546 /* wc is unicode */
547 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!wc!%2!wc!%3!wc!%1!wc!", 0,
548 0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
549 ok(!strcmp("test", out),"failed out=[%s]\n",out);
550 ok(r==4,"failed: r=%d\n",r);
551
552 /* C is unicode */
553 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!C!%2!C!%3!C!%1!C!", 0,
554 0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
555 ok(!strcmp("test", out),"failed out=[%s]\n",out);
556 ok(r==4,"failed: r=%d\n",r);
557
558 /* some numbers */
559 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!d!%2!d!%3!d!", 0,
560 0, out, sizeof(out)/sizeof(CHAR), 1,2,3);
561 ok(!strcmp("123", out),"failed out=[%s]\n",out);
562 ok(r==3,"failed: r=%d\n",r);
563
564 /* a single digit with some spacing */
565 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4d!", 0,
566 0, out, sizeof(out)/sizeof(CHAR), 1);
567 ok(!strcmp(" 1", out),"failed out=[%s]\n",out);
568 ok(r==4,"failed: r=%d\n",r);
569
570 /* a single digit, left justified */
571 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!-4d!", 0,
572 0, out, sizeof(out)/sizeof(CHAR), 1);
573 ok(!strcmp("1 ", out),"failed out=[%s]\n",out);
574 ok(r==4,"failed: r=%d\n",r);
575
576 /* two digit decimal number */
577 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4d!", 0,
578 0, out, sizeof(out)/sizeof(CHAR), 11);
579 ok(!strcmp(" 11", out),"failed out=[%s]\n",out);
580 ok(r==4,"failed: r=%d\n",r);
581
582 /* a hex number */
583 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4x!", 0,
584 0, out, sizeof(out)/sizeof(CHAR), 11);
585 ok(!strcmp(" b", out),"failed out=[%s]\n",out);
586 ok(r==4,"failed: r=%d\n",r);
587
588 /* a hex number, upper case */
589 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4X!", 0,
590 0, out, sizeof(out)/sizeof(CHAR), 11);
591 ok(!strcmp(" B", out),"failed out=[%s]\n",out);
592 ok(r==4,"failed: r=%d\n",r);
593
594 /* a hex number, upper case, left justified */
595 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!-4X!", 0,
596 0, out, sizeof(out)/sizeof(CHAR), 11);
597 ok(!strcmp("B ", out),"failed out=[%s]\n",out);
598 ok(r==4,"failed: r=%d\n",r);
599
600 /* a long hex number, upper case */
601 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4X!", 0,
602 0, out, sizeof(out)/sizeof(CHAR), 0x1ab);
603 ok(!strcmp(" 1AB", out),"failed out=[%s]\n",out);
604 ok(r==4,"failed: r=%d\n",r);
605
606 /* two percent... */
607 r = doit(FORMAT_MESSAGE_FROM_STRING, " %%%% ", 0,
608 0, out, sizeof(out)/sizeof(CHAR));
609 ok(!strcmp(" %% ", out),"failed out=[%s]\n",out);
610 ok(r==4,"failed: r=%d\n",r);
611
612 /* periods are special cases */
613 r = doit(FORMAT_MESSAGE_FROM_STRING, " %.%. %1!d!", 0,
614 0, out, sizeof(out)/sizeof(CHAR), 0x1ab);
615 ok(!strcmp(" .. 427", out),"failed out=[%s]\n",out);
616 ok(r==7,"failed: r=%d\n",r);
617
618 /* %0 ends the line */
619 r = doit(FORMAT_MESSAGE_FROM_STRING, "test%0test", 0,
620 0, out, sizeof(out)/sizeof(CHAR));
621 ok(!strcmp("test", out),"failed out=[%s]\n",out);
622 ok(r==4,"failed: r=%d\n",r);
623
624 /* %! prints an exclamation */
625 r = doit(FORMAT_MESSAGE_FROM_STRING, "yah%!%0 ", 0,
626 0, out, sizeof(out)/sizeof(CHAR));
627 ok(!strcmp("yah!", out),"failed out=[%s]\n",out);
628 ok(r==4,"failed: r=%d\n",r);
629
630 /* %space */
631 r = doit(FORMAT_MESSAGE_FROM_STRING, "% % ", 0,
632 0, out, sizeof(out)/sizeof(CHAR));
633 ok(!strcmp(" ", out),"failed out=[%s]\n",out);
634 ok(r==4,"failed: r=%d\n",r);
635
636 /* line feed */
637 r = doit(FORMAT_MESSAGE_FROM_STRING, "hi\n", 0,
638 0, out, sizeof(out)/sizeof(CHAR));
639 ok(!strcmp("hi\r\n", out),"failed out=[%s]\n",out);
640 ok(r==4,"failed: r=%d\n",r);
641
642 /* carriage return line feed */
643 r = doit(FORMAT_MESSAGE_FROM_STRING, "hi\r\n", 0,
644 0, out, sizeof(out)/sizeof(CHAR));
645 ok(!strcmp("hi\r\n", out),"failed out=[%s]\n",out);
646 ok(r==4,"failed: r=%d\n",r);
647
648 /* carriage return */
649 r = doit(FORMAT_MESSAGE_FROM_STRING, "\r", 0,
650 0, out, sizeof(out)/sizeof(CHAR));
651 ok(!strcmp("\r\n", out),"failed out=[%s]\n",out);
652 ok(r==2,"failed: r=%d\n",r);
653
654 /* double carriage return line feed */
655 r = doit(FORMAT_MESSAGE_FROM_STRING, "\r\r\n", 0,
656 0, out, sizeof(out)/sizeof(CHAR));
657 ok(!strcmp("\r\n\r\n", out),"failed out=[%s]\n",out);
658 ok(r==4,"failed: r=%d\n",r);
659
660 /* precision and width */
661
662 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!3s!",
663 0, 0, out, sizeof(out), "t" );
664 ok(!strcmp(" t", out),"failed out=[%s]\n",out);
665 ok(r==3, "failed: r=%d\n",r);
666 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*s!",
667 0, 0, out, sizeof(out), 4, "t");
668 if (!strcmp("*s",out)) win_skip( "width/precision not supported\n" );
669 else
670 {
671 ok(!strcmp( " t", out),"failed out=[%s]\n",out);
672 ok(r==4,"failed: r=%d\n",r);
673 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4.2u!",
674 0, 0, out, sizeof(out), 3 );
675 ok(!strcmp( " 03", out),"failed out=[%s]\n",out);
676 ok(r==4,"failed: r=%d\n",r);
677 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*.*u!",
678 0, 0, out, sizeof(out), 5, 3, 1 );
679 ok(!strcmp( " 001", out),"failed out=[%s]\n",out);
680 ok(r==5,"failed: r=%d\n",r);
681 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*.*u!,%1!*.*u!",
682 0, 0, out, sizeof(out), 5, 3, 1, 4, 2 );
683 ok(!strcmp( " 001, 0002", out),"failed out=[%s]\n",out);
684 ok(r==11,"failed: r=%d\n",r);
685 r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*.*u!,%3!*.*u!",
686 0, 0, out, sizeof(out), 5, 3, 1, 6, 4, 2 );
687 /* older Win versions marked as broken even though this is arguably the correct behavior */
688 /* but the new (brain-damaged) behavior is specified on MSDN */
689 ok(!strcmp( " 001, 0002", out) || broken(!strcmp(" 001,000004", out)),
690 "failed out=[%s]\n",out);
691 ok(r==12,"failed: r=%d\n",r);
692 /* args are not counted the same way with an argument array */
693 {
694 ULONG_PTR args[] = { 6, 4, 2, 5, 3, 1 };
695 r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
696 "%1!*.*u!,%1!*.*u!", 0, 0, out, sizeof(out), (__ms_va_list *)args );
697 ok(!strcmp(" 0002, 00003", out),"failed out=[%s]\n",out);
698 ok(r==13,"failed: r=%d\n",r);
699 r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
700 "%1!*.*u!,%4!*.*u!", 0, 0, out, sizeof(out), (__ms_va_list *)args );
701 ok(!strcmp(" 0002, 001", out),"failed out=[%s]\n",out);
702 ok(r==12,"failed: r=%d\n",r);
703 }
704 }
705
706 /* change of pace... test the low byte of dwflags */
707
708 /* line feed */
709 r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "hi\n", 0,
710 0, out, sizeof(out)/sizeof(CHAR));
711 ok(!strcmp("hi ", out) || !strcmp("hi\r\n", out),"failed out=[%s]\n",out);
712 ok(r==3 || r==4,"failed: r=%d\n",r);
713
714 /* carriage return line feed */
715 r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "hi\r\n", 0,
716 0, out, sizeof(out)/sizeof(CHAR));
717 ok(!strcmp("hi ", out),"failed out=[%s]\n",out);
718 ok(r==3,"failed: r=%d\n",r);
719
720 /* carriage return */
721 r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "\r", 0,
722 0, out, sizeof(out)/sizeof(CHAR));
723 ok(!strcmp(" ", out),"failed out=[%s]\n",out);
724 ok(r==1,"failed: r=%d\n",r);
725
726 /* double carriage return line feed */
727 r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "\r\r\n", 0,
728 0, out, sizeof(out)/sizeof(CHAR));
729 ok(!strcmp(" ", out),"failed out=[%s]\n",out);
730 ok(r==2,"failed: r=%d\n",r);
731 }
732
733 static void test_message_ignore_inserts(void)
734 {
735 static const char init_buf[] = {'x', 'x', 'x', 'x', 'x'};
736
737 DWORD ret;
738 CHAR out[256];
739
740 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, "test", 0, 0, out,
741 sizeof(out)/sizeof(CHAR), NULL);
742 ok(ret == 4, "Expected FormatMessageA to return 4, got %d\n", ret);
743 ok(!strcmp("test", out), "Expected output string \"test\", got %s\n", out);
744
745 /* The %0 escape sequence is handled. */
746 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, "test%0", 0, 0, out,
747 sizeof(out)/sizeof(CHAR), NULL);
748 ok(ret == 4, "Expected FormatMessageA to return 4, got %d\n", ret);
749 ok(!strcmp("test", out), "Expected output string \"test\", got %s\n", out);
750
751 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, "test%0test", 0, 0, out,
752 sizeof(out)/sizeof(CHAR), NULL);
753 ok(ret == 4, "Expected FormatMessageA to return 4, got %d\n", ret);
754 ok(!strcmp("test", out), "Expected output string \"test\", got %s\n", out);
755
756 /* While FormatMessageA returns 0 in this case, no last error code is set. */
757 SetLastError(0xdeadbeef);
758 memcpy(out, init_buf, sizeof(init_buf));
759 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, "%0test", 0, 0, out,
760 sizeof(out)/sizeof(CHAR), NULL);
761 ok(ret == 0, "Expected FormatMessageA to return 0, got %d\n", ret);
762 ok(!memcmp(out, init_buf, sizeof(init_buf)) ||
763 broken(!strcmp("", out)), /* Win9x */
764 "Expected the output buffer to be untouched\n");
765 ok(GetLastError() == 0xdeadbeef, "Expected GetLastError() to return 0xdeadbeef, got %u\n", GetLastError());
766
767 /* Insert sequences are ignored. */
768 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, "test%1%2!*.*s!%99", 0, 0, out,
769 sizeof(out)/sizeof(CHAR), NULL);
770 ok(ret == 17, "Expected FormatMessageA to return 17, got %d\n", ret);
771 ok(!strcmp("test%1%2!*.*s!%99", out), "Expected output string \"test%%1%%2!*.*s!%%99\", got %s\n", out);
772
773 /* Only the "%n", "%r", and "%t" escape sequences are processed. */
774 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, "%%% %.%!", 0, 0, out,
775 sizeof(out)/sizeof(CHAR), NULL);
776 ok(ret == 8 ||
777 broken(ret == 7) /* Win9x */,
778 "Expected FormatMessageA to return 8, got %d\n", ret);
779 ok(!strcmp("%%% %.%!", out) ||
780 broken(!strcmp("%%% %.!", out)) /* Win9x */,
781 "Expected output string \"%%%%%% %%.%%!\", got %s\n", out);
782
783 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, "%n%r%t", 0, 0, out,
784 sizeof(out)/sizeof(CHAR), NULL);
785 ok(ret == 4, "Expected FormatMessageA to return 4, got %d\n", ret);
786 ok(!strcmp("\r\n\r\t", out), "Expected output string \"\\r\\n\\r\\t\", got %s\n", out);
787 }
788
789 static void test_message_ignore_inserts_wide(void)
790 {
791 static const WCHAR test[] = {'t','e','s','t',0};
792 static const WCHAR empty[] = {0};
793 static const WCHAR fmt_t0[] = {'t','e','s','t','%','0',0};
794 static const WCHAR fmt_t0t[] = {'t','e','s','t','%','0','t','e','s','t',0};
795 static const WCHAR fmt_0t[] = {'%','0','t','e','s','t',0};
796 static const WCHAR fmt_t12oos99[] = {'t','e','s','t','%','1','%','2','!','*','.','*','s','!','%','9','9',0};
797 static const WCHAR fmt_pctspacedot[] = {'%','%','%',' ','%','.','%','!',0};
798 static const WCHAR fmt_nrt[] = {'%','n','%','r','%','t',0};
799
800 static const WCHAR s_nrt[] = {'\r','\n','\r','\t',0};
801
802 DWORD ret;
803 WCHAR out[256];
804
805 SetLastError(0xdeadbeef);
806 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
807 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
808 {
809 win_skip("FormatMessageW is not implemented\n");
810 return;
811 }
812
813 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, test, 0, 0, out,
814 sizeof(out)/sizeof(WCHAR), NULL);
815 ok(ret == 4, "Expected FormatMessageW to return 4, got %d\n", ret);
816 ok(!lstrcmpW(test, out), "Expected output string \"test\", got %s\n", wine_dbgstr_w(out));
817
818 /* The %0 escape sequence is handled. */
819 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, fmt_t0, 0, 0, out,
820 sizeof(out)/sizeof(WCHAR), NULL);
821 ok(ret == 4, "Expected FormatMessageW to return 4, got %d\n", ret);
822 ok(!lstrcmpW(test, out), "Expected output string \"test\", got %s\n", wine_dbgstr_w(out));
823
824 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, fmt_t0t, 0, 0, out,
825 sizeof(out)/sizeof(WCHAR), NULL);
826 ok(ret == 4, "Expected FormatMessageW to return 4, got %d\n", ret);
827 ok(!lstrcmpW(test, out), "Expected output string \"test\", got %s\n", wine_dbgstr_w(out));
828
829 /* While FormatMessageA returns 0 in this case, no last error code is set. */
830 SetLastError(0xdeadbeef);
831 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, fmt_0t, 0, 0, out,
832 sizeof(out)/sizeof(WCHAR), NULL);
833 ok(ret == 0, "Expected FormatMessageW to return 0, got %d\n", ret);
834 ok(!lstrcmpW(empty, out), "Expected the output buffer to be the empty string, got %s\n", wine_dbgstr_w(out));
835 ok(GetLastError() == 0xdeadbeef, "Expected GetLastError() to return 0xdeadbeef, got %u\n", GetLastError());
836
837 /* Insert sequences are ignored. */
838 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, fmt_t12oos99, 0, 0, out,
839 sizeof(out)/sizeof(WCHAR), NULL);
840 ok(ret == 17, "Expected FormatMessageW to return 17, got %d\n", ret);
841 ok(!lstrcmpW(fmt_t12oos99, out), "Expected output string \"test%%1%%2!*.*s!%%99\", got %s\n", wine_dbgstr_w(out));
842
843 /* Only the "%n", "%r", and "%t" escape sequences are processed. */
844 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, fmt_pctspacedot, 0, 0, out,
845 sizeof(out)/sizeof(WCHAR), NULL);
846 ok(ret == 8, "Expected FormatMessageW to return 8, got %d\n", ret);
847 ok(!lstrcmpW(fmt_pctspacedot, out), "Expected output string \"%%%%%% %%.%%!\", got %s\n", wine_dbgstr_w(out));
848
849 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_IGNORE_INSERTS, fmt_nrt, 0, 0, out,
850 sizeof(out)/sizeof(WCHAR), NULL);
851 ok(ret == 4, "Expected FormatMessageW to return 4, got %d\n", ret);
852 ok(!lstrcmpW(s_nrt, out), "Expected output string \"\\r\\n\\r\\t\", got %s\n", wine_dbgstr_w(out));
853 }
854
855 static void test_message_insufficient_buffer(void)
856 {
857 static const char init_buf[] = {'x', 'x', 'x', 'x', 'x'};
858 static const char expected_buf[] = {'x', 'x', 'x', 'x', 'x'};
859 DWORD ret;
860 CHAR out[5];
861
862 SetLastError(0xdeadbeef);
863 memcpy(out, init_buf, sizeof(init_buf));
864 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0, 0, out, 0, NULL);
865 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
866 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
867 "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
868 GetLastError());
869 ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
870 "Expected the buffer to be untouched\n");
871
872 SetLastError(0xdeadbeef);
873 memcpy(out, init_buf, sizeof(init_buf));
874 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0, 0, out, 1, NULL);
875 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
876 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
877 "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
878 GetLastError());
879 ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
880 "Expected the buffer to be untouched\n");
881
882 SetLastError(0xdeadbeef);
883 memcpy(out, init_buf, sizeof(init_buf));
884 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0, 0, out, sizeof(out)/sizeof(out[0]) - 1, NULL);
885 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
886 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
887 "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
888 GetLastError());
889 ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
890 "Expected the buffer to be untouched\n");
891 }
892
893 static void test_message_insufficient_buffer_wide(void)
894 {
895 static const WCHAR test[] = {'t','e','s','t',0};
896 static const WCHAR init_buf[] = {'x', 'x', 'x', 'x', 'x'};
897 static const WCHAR expected_buf[] = {'x', 'x', 'x', 'x', 'x'};
898 static const WCHAR broken_buf[] = {0, 'x', 'x', 'x', 'x'};
899 static const WCHAR broken2_buf[] = {'t','e','s',0,'x'};
900
901 DWORD ret;
902 WCHAR out[5];
903
904 SetLastError(0xdeadbeef);
905 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
906 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
907 {
908 win_skip("FormatMessageW is not implemented\n");
909 return;
910 }
911
912 SetLastError(0xdeadbeef);
913 memcpy(out, init_buf, sizeof(init_buf));
914 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0, 0, out, 0, NULL);
915 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
916 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
917 "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
918 GetLastError());
919 ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
920 "Expected the buffer to be untouched\n");
921
922 /* Windows Server 2003 and newer report failure but copy a
923 * truncated string to the buffer for non-zero buffer sizes. */
924 SetLastError(0xdeadbeef);
925 memcpy(out, init_buf, sizeof(init_buf));
926 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0, 0, out, 1, NULL);
927 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
928 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
929 "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
930 GetLastError());
931 ok(!memcmp(expected_buf, out, sizeof(expected_buf)) ||
932 broken(!memcmp(broken_buf, out, sizeof(broken_buf))), /* W2K3+ */
933 "Expected the buffer to be untouched\n");
934
935 SetLastError(0xdeadbeef);
936 memcpy(out, init_buf, sizeof(init_buf));
937 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0, 0, out, sizeof(out)/sizeof(out[0]) - 1, NULL);
938 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
939 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
940 "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
941 GetLastError());
942 ok(!memcmp(expected_buf, out, sizeof(expected_buf)) ||
943 broken(!memcmp(broken2_buf, out, sizeof(broken2_buf))), /* W2K3+ */
944 "Expected the buffer to be untouched\n");
945 }
946
947 static void test_message_null_buffer(void)
948 {
949 DWORD ret, error;
950
951 /* Without FORMAT_MESSAGE_ALLOCATE_BUFFER, only the specified buffer size is checked. */
952 SetLastError(0xdeadbeef);
953 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 0, NULL);
954 error = GetLastError();
955 ok(!ret, "FormatMessageA returned %u\n", ret);
956 ok(error == ERROR_INSUFFICIENT_BUFFER ||
957 error == ERROR_INVALID_PARAMETER, /* win9x */
958 "last error %u\n", error);
959
960 SetLastError(0xdeadbeef);
961 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 1, NULL);
962 error = GetLastError();
963 ok(!ret, "FormatMessageA returned %u\n", ret);
964 ok(error == ERROR_INSUFFICIENT_BUFFER ||
965 error == ERROR_INVALID_PARAMETER, /* win9x */
966 "last error %u\n", error);
967
968 if (0) /* crashes on Windows */
969 {
970 SetLastError(0xdeadbeef);
971 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 256, NULL);
972 error = GetLastError();
973 ok(!ret, "FormatMessageA returned %u\n", ret);
974 trace("last error %u\n", error);
975 }
976
977 SetLastError(0xdeadbeef);
978 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 0, NULL);
979 error = GetLastError();
980 ok(!ret, "FormatMessageA returned %u\n", ret);
981 ok(error == ERROR_NOT_ENOUGH_MEMORY ||
982 error == ERROR_INVALID_PARAMETER, /* win9x */
983 "last error %u\n", error);
984
985 SetLastError(0xdeadbeef);
986 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 1, NULL);
987 error = GetLastError();
988 ok(!ret, "FormatMessageA returned %u\n", ret);
989 ok(error == ERROR_NOT_ENOUGH_MEMORY ||
990 error == ERROR_INVALID_PARAMETER, /* win9x */
991 "last error %u\n", error);
992
993 SetLastError(0xdeadbeef);
994 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 256, NULL);
995 error = GetLastError();
996 ok(!ret, "FormatMessageA returned %u\n", ret);
997 ok(error == ERROR_NOT_ENOUGH_MEMORY ||
998 error == ERROR_INVALID_PARAMETER, /* win9x */
999 "last error %u\n", error);
1000 }
1001
1002 static void test_message_null_buffer_wide(void)
1003 {
1004 DWORD ret, error;
1005
1006 SetLastError(0xdeadbeef);
1007 ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 0, NULL);
1008 error = GetLastError();
1009 if (!ret && error == ERROR_CALL_NOT_IMPLEMENTED)
1010 {
1011 win_skip("FormatMessageW is not implemented\n");
1012 return;
1013 }
1014
1015 SetLastError(0xdeadbeef);
1016 ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 0, NULL);
1017 error = GetLastError();
1018 ok(!ret, "FormatMessageW returned %u\n", ret);
1019 ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
1020
1021 SetLastError(0xdeadbeef);
1022 ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 1, NULL);
1023 error = GetLastError();
1024 ok(!ret, "FormatMessageW returned %u\n", ret);
1025 ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
1026
1027 SetLastError(0xdeadbeef);
1028 ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 256, NULL);
1029 error = GetLastError();
1030 ok(!ret, "FormatMessageW returned %u\n", ret);
1031 ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
1032
1033 SetLastError(0xdeadbeef);
1034 ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 0, NULL);
1035 error = GetLastError();
1036 ok(!ret, "FormatMessageW returned %u\n", ret);
1037 ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
1038
1039 SetLastError(0xdeadbeef);
1040 ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 1, NULL);
1041 error = GetLastError();
1042 ok(!ret, "FormatMessageW returned %u\n", ret);
1043 ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
1044
1045 SetLastError(0xdeadbeef);
1046 ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 256, NULL);
1047 error = GetLastError();
1048 ok(!ret, "FormatMessageW returned %u\n", ret);
1049 ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
1050 }
1051
1052 static void test_message_allocate_buffer(void)
1053 {
1054 DWORD ret;
1055 char *buf;
1056
1057 /* While MSDN suggests that FormatMessageA allocates a buffer whose size is
1058 * the larger of the output string and the requested buffer size, the tests
1059 * will not try to determine the actual size of the buffer allocated, as
1060 * the return value of LocalSize cannot be trusted for the purpose, and it should
1061 * in any case be safe for FormatMessageA to allocate in the manner that
1062 * MSDN suggests. */
1063
1064 SetLastError(0xdeadbeef);
1065 buf = (char *)0xdeadbeef;
1066 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1067 "", 0, 0, (char *)&buf, 0, NULL);
1068 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
1069 ok(buf == NULL, "Expected output buffer pointer to be NULL\n");
1070 ok(GetLastError() == 0xdeadbeef,
1071 "Expected last error to be untouched, got %u\n", GetLastError());
1072
1073 buf = (char *)0xdeadbeef;
1074 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1075 "test", 0, 0, (char *)&buf, 0, NULL);
1076 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1077 ok(buf != NULL && buf != (char *)0xdeadbeef,
1078 "Expected output buffer pointer to be valid\n");
1079 if (buf != NULL && buf != (char *)0xdeadbeef)
1080 {
1081 ok(!strcmp("test", buf),
1082 "Expected buffer to contain \"test\", got %s\n", buf);
1083 LocalFree(buf);
1084 }
1085
1086 buf = (char *)0xdeadbeef;
1087 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1088 "test", 0, 0, (char *)&buf, strlen("test"), NULL);
1089 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1090 ok(buf != NULL && buf != (char *)0xdeadbeef,
1091 "Expected output buffer pointer to be valid\n");
1092 if (buf != NULL && buf != (char *)0xdeadbeef)
1093 {
1094 ok(!strcmp("test", buf),
1095 "Expected buffer to contain \"test\", got %s\n", buf);
1096 LocalFree(buf);
1097 }
1098
1099 buf = (char *)0xdeadbeef;
1100 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1101 "test", 0, 0, (char *)&buf, strlen("test") + 1, NULL);
1102 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1103 ok(buf != NULL && buf != (char *)0xdeadbeef,
1104 "Expected output buffer pointer to be valid\n");
1105 if (buf != NULL && buf != (char *)0xdeadbeef)
1106 {
1107 ok(!strcmp("test", buf),
1108 "Expected buffer to contain \"test\", got %s\n", buf);
1109 LocalFree(buf);
1110 }
1111
1112 buf = (char *)0xdeadbeef;
1113 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1114 "test", 0, 0, (char *)&buf, strlen("test") + 2, NULL);
1115 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1116 ok(buf != NULL && buf != (char *)0xdeadbeef,
1117 "Expected output buffer pointer to be valid\n");
1118 if (buf != NULL && buf != (char *)0xdeadbeef)
1119 {
1120 ok(!strcmp("test", buf),
1121 "Expected buffer to contain \"test\", got %s\n", buf);
1122 LocalFree(buf);
1123 }
1124
1125 buf = (char *)0xdeadbeef;
1126 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1127 "test", 0, 0, (char *)&buf, 1024, NULL);
1128 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1129 ok(buf != NULL && buf != (char *)0xdeadbeef,
1130 "Expected output buffer pointer to be valid\n");
1131 if (buf != NULL && buf != (char *)0xdeadbeef)
1132 {
1133 ok(!strcmp("test", buf),
1134 "Expected buffer to contain \"test\", got %s\n", buf);
1135 LocalFree(buf);
1136 }
1137 }
1138
1139 static void test_message_allocate_buffer_wide(void)
1140 {
1141 static const WCHAR empty[] = {0};
1142 static const WCHAR test[] = {'t','e','s','t',0};
1143
1144 DWORD ret;
1145 WCHAR *buf;
1146
1147 SetLastError(0xdeadbeef);
1148 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
1149 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1150 {
1151 win_skip("FormatMessageW is not implemented\n");
1152 return;
1153 }
1154
1155 /* While MSDN suggests that FormatMessageW allocates a buffer whose size is
1156 * the larger of the output string and the requested buffer size, the tests
1157 * will not try to determine the actual size of the buffer allocated, as
1158 * the return value of LocalSize cannot be trusted for the purpose, and it should
1159 * in any case be safe for FormatMessageW to allocate in the manner that
1160 * MSDN suggests. */
1161
1162 if (0) /* crashes on Windows */
1163 {
1164 buf = (WCHAR *)0xdeadbeef;
1165 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1166 NULL, 0, 0, (WCHAR *)&buf, 0, NULL);
1167 }
1168
1169 SetLastError(0xdeadbeef);
1170 buf = (WCHAR *)0xdeadbeef;
1171 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1172 empty, 0, 0, (WCHAR *)&buf, 0, NULL);
1173 ok(ret == 0, "Expected FormatMessageW to return 0, got %u\n", ret);
1174 ok(buf == NULL, "Expected output buffer pointer to be NULL\n");
1175 ok(GetLastError() == 0xdeadbeef,
1176 "Expected last error to be untouched, got %u\n", GetLastError());
1177
1178 buf = (WCHAR *)0xdeadbeef;
1179 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1180 test, 0, 0, (WCHAR *)&buf, 0, NULL);
1181 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1182 ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1183 "Expected output buffer pointer to be valid\n");
1184 if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1185 {
1186 ok(!lstrcmpW(test, buf),
1187 "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1188 LocalFree(buf);
1189 }
1190
1191 buf = (WCHAR *)0xdeadbeef;
1192 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1193 test, 0, 0, (WCHAR *)&buf, sizeof(test)/sizeof(WCHAR) - 1, NULL);
1194 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1195 ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1196 "Expected output buffer pointer to be valid\n");
1197 if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1198 {
1199 ok(!lstrcmpW(test, buf),
1200 "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1201 LocalFree(buf);
1202 }
1203
1204 buf = (WCHAR *)0xdeadbeef;
1205 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1206 test, 0, 0, (WCHAR *)&buf, sizeof(test)/sizeof(WCHAR), NULL);
1207 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1208 ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1209 "Expected output buffer pointer to be valid\n");
1210 if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1211 {
1212 ok(!lstrcmpW(test, buf),
1213 "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1214 LocalFree(buf);
1215 }
1216
1217 buf = (WCHAR *)0xdeadbeef;
1218 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1219 test, 0, 0, (WCHAR *)&buf, sizeof(test)/sizeof(WCHAR) + 1, NULL);
1220 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1221 ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1222 "Expected output buffer pointer to be valid\n");
1223 if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1224 {
1225 ok(!lstrcmpW(test, buf),
1226 "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1227 LocalFree(buf);
1228 }
1229
1230 buf = (WCHAR *)0xdeadbeef;
1231 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1232 test, 0, 0, (WCHAR *)&buf, 1024, NULL);
1233 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1234 ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1235 "Expected output buffer pointer to be valid\n");
1236 if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1237 {
1238 ok(!lstrcmpW(test, buf),
1239 "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1240 LocalFree(buf);
1241 }
1242 }
1243
1244 static void test_message_from_hmodule(void)
1245 {
1246 DWORD ret, error;
1247 HMODULE h;
1248 CHAR out[0x100] = {0};
1249
1250 h = GetModuleHandle("kernel32.dll");
1251 ok(h != 0, "GetModuleHandle failed\n");
1252
1253 /*Test existing messageID; as the message strings from wine's kernel32 differ from windows' kernel32 we don't compare
1254 the strings but only test that FormatMessage doesn't return 0*/
1255 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 7/*=ERROR_ARENA_TRASHED*/,
1256 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), out, sizeof(out)/sizeof(CHAR), NULL);
1257 ok(ret != 0, "FormatMessageA returned 0\n");
1258
1259 /*Test nonexistent messageID with varying language ID's Note: FormatMessageW behaves the same*/
1260 SetLastError(0xdeadbeef);
1261 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1262 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), out, sizeof(out)/sizeof(CHAR), NULL);
1263 error = GetLastError();
1264 ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1265 ok(error == ERROR_MR_MID_NOT_FOUND || error == ERROR_MUI_FILE_NOT_FOUND, "last error %u\n", error);
1266
1267 SetLastError(0xdeadbeef);
1268 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1269 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), out, sizeof(out)/sizeof(CHAR), NULL);
1270 error = GetLastError();
1271 ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1272 ok(error == ERROR_MR_MID_NOT_FOUND || error == ERROR_MUI_FILE_NOT_LOADED, "last error %u\n", error);
1273
1274 SetLastError(0xdeadbeef);
1275 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1276 MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT), out, sizeof(out)/sizeof(CHAR), NULL);
1277 error = GetLastError();
1278 ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1279 ok(error == ERROR_MR_MID_NOT_FOUND || error == ERROR_MUI_FILE_NOT_LOADED, "last error %u\n", error);
1280
1281 SetLastError(0xdeadbeef);
1282 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1283 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), out, sizeof(out)/sizeof(CHAR), NULL);
1284 error = GetLastError();
1285 ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1286 ok(error == ERROR_RESOURCE_LANG_NOT_FOUND ||
1287 error == ERROR_MR_MID_NOT_FOUND ||
1288 error == ERROR_MUI_FILE_NOT_FOUND ||
1289 error == ERROR_MUI_FILE_NOT_LOADED,
1290 "last error %u\n", error);
1291
1292 SetLastError(0xdeadbeef);
1293 ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1294 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_UK), out, sizeof(out)/sizeof(CHAR), NULL);
1295 error = GetLastError();
1296 ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1297 ok(error == ERROR_RESOURCE_LANG_NOT_FOUND ||
1298 error == ERROR_MR_MID_NOT_FOUND ||
1299 error == ERROR_MUI_FILE_NOT_FOUND ||
1300 error == ERROR_MUI_FILE_NOT_LOADED,
1301 "last error %u\n", error);
1302 }
1303
1304 static void test_message_invalid_flags(void)
1305 {
1306 static const char init_buf[] = {'x', 'x', 'x', 'x', 'x'};
1307
1308 DWORD ret;
1309 CHAR out[5];
1310 char *ptr;
1311
1312 SetLastError(0xdeadbeef);
1313 memcpy(out, init_buf, sizeof(init_buf));
1314 ret = FormatMessageA(0, "test", 0, 0, out, sizeof(out)/sizeof(CHAR), NULL);
1315 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
1316 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1317 "Expected the output buffer to be untouched\n");
1318 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1319 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1320 GetLastError());
1321
1322 SetLastError(0xdeadbeef);
1323 ptr = (char *)0xdeadbeef;
1324 ret = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER, "test", 0, 0, (char *)&ptr, 0, NULL);
1325 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
1326 ok(ptr == NULL ||
1327 broken(ptr == (char *)0xdeadbeef), /* Win9x */
1328 "Expected output pointer to be initialized to NULL, got %p\n", ptr);
1329 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1330 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1331 GetLastError());
1332
1333 SetLastError(0xdeadbeef);
1334 memcpy(out, init_buf, sizeof(init_buf));
1335 ret = FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS, "test", 0, 0, out, sizeof(out)/sizeof(CHAR), NULL);
1336 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
1337 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1338 "Expected the output buffer to be untouched\n");
1339 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1340 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1341 GetLastError());
1342
1343 SetLastError(0xdeadbeef);
1344 memcpy(out, init_buf, sizeof(init_buf));
1345 ret = FormatMessageA(FORMAT_MESSAGE_ARGUMENT_ARRAY, "test", 0, 0, out, sizeof(out)/sizeof(CHAR), NULL);
1346 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
1347 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1348 "Expected the output buffer to be untouched\n");
1349 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1350 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1351 GetLastError());
1352
1353 SetLastError(0xdeadbeef);
1354 memcpy(out, init_buf, sizeof(init_buf));
1355 ret = FormatMessageA(FORMAT_MESSAGE_MAX_WIDTH_MASK, "test", 0, 0, out, sizeof(out)/sizeof(CHAR), NULL);
1356 ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
1357 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1358 "Expected the output buffer to be untouched\n");
1359 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1360 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1361 GetLastError());
1362
1363 /* Simultaneously setting FORMAT_MESSAGE_FROM_STRING with other source
1364 * flags is apparently permissible, and FORMAT_MESSAGE_FROM_STRING takes
1365 * precedence in this case. */
1366
1367 memcpy(out, init_buf, sizeof(init_buf));
1368 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_FROM_SYSTEM,
1369 "test", 0, 0, out, sizeof(out)/sizeof(CHAR), NULL);
1370 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1371 ok(!strcmp("test", out),
1372 "Expected the output buffer to be untouched\n");
1373
1374 memcpy(out, init_buf, sizeof(init_buf));
1375 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_FROM_HMODULE,
1376 "test", 0, 0, out, sizeof(out)/sizeof(CHAR), NULL);
1377 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1378 ok(!strcmp("test", out),
1379 "Expected the output buffer to be untouched\n");
1380
1381 memcpy(out, init_buf, sizeof(init_buf));
1382 ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_FROM_HMODULE |
1383 FORMAT_MESSAGE_FROM_SYSTEM, "test", 0, 0, out,
1384 sizeof(out)/sizeof(CHAR), NULL);
1385 ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1386 ok(!strcmp("test", out),
1387 "Expected the output buffer to be untouched\n");
1388 }
1389
1390 static void test_message_invalid_flags_wide(void)
1391 {
1392 static const WCHAR init_buf[] = {'x', 'x', 'x', 'x', 'x'};
1393 static const WCHAR test[] = {'t','e','s','t',0};
1394
1395 DWORD ret;
1396 WCHAR out[5];
1397 WCHAR *ptr;
1398
1399 SetLastError(0xdeadbeef);
1400 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
1401 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1402 {
1403 win_skip("FormatMessageW is not implemented\n");
1404 return;
1405 }
1406
1407 SetLastError(0xdeadbeef);
1408 memcpy(out, init_buf, sizeof(init_buf));
1409 ret = FormatMessageW(0, test, 0, 0, out, sizeof(out)/sizeof(WCHAR), NULL);
1410 ok(ret == 0, "Expected FormatMessageW to return 0, got %u\n", ret);
1411 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1412 "Expected the output buffer to be untouched\n");
1413 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1414 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1415 GetLastError());
1416
1417 SetLastError(0xdeadbeef);
1418 ptr = (WCHAR *)0xdeadbeef;
1419 ret = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER, test, 0, 0, (WCHAR *)&ptr, 0, NULL);
1420 ok(ret == 0, "Expected FormatMessageW to return 0, got %u\n", ret);
1421 ok(ptr == NULL, "Expected output pointer to be initialized to NULL, got %p\n", ptr);
1422 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1423 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1424 GetLastError());
1425
1426 SetLastError(0xdeadbeef);
1427 memcpy(out, init_buf, sizeof(init_buf));
1428 ret = FormatMessageW(FORMAT_MESSAGE_IGNORE_INSERTS, test, 0, 0, out, sizeof(out)/sizeof(WCHAR), NULL);
1429 ok(ret == 0, "Expected FormatMessageW to return 0, got %u\n", ret);
1430 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1431 "Expected the output buffer to be untouched\n");
1432 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1433 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1434 GetLastError());
1435
1436 SetLastError(0xdeadbeef);
1437 memcpy(out, init_buf, sizeof(init_buf));
1438 ret = FormatMessageW(FORMAT_MESSAGE_ARGUMENT_ARRAY, test, 0, 0, out, sizeof(out)/sizeof(WCHAR), NULL);
1439 ok(ret == 0, "Expected FormatMessageW to return 0, got %u\n", ret);
1440 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1441 "Expected the output buffer to be untouched\n");
1442 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1443 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1444 GetLastError());
1445
1446 SetLastError(0xdeadbeef);
1447 memcpy(out, init_buf, sizeof(init_buf));
1448 ret = FormatMessageW(FORMAT_MESSAGE_MAX_WIDTH_MASK, test, 0, 0, out, sizeof(out)/sizeof(WCHAR), NULL);
1449 ok(ret == 0, "Expected FormatMessageW to return 0, got %u\n", ret);
1450 ok(!memcmp(out, init_buf, sizeof(init_buf)),
1451 "Expected the output buffer to be untouched\n");
1452 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1453 "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
1454 GetLastError());
1455
1456 /* Simultaneously setting FORMAT_MESSAGE_FROM_STRING with other source
1457 * flags is apparently permissible, and FORMAT_MESSAGE_FROM_STRING takes
1458 * precedence in this case. */
1459
1460 memcpy(out, init_buf, sizeof(init_buf));
1461 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_FROM_SYSTEM,
1462 test, 0, 0, out, sizeof(out)/sizeof(WCHAR), NULL);
1463 ok(ret == 4, "Expected FormatMessageW to return 4, got %u\n", ret);
1464 ok(!lstrcmpW(test, out),
1465 "Expected the output buffer to be untouched\n");
1466
1467 memcpy(out, init_buf, sizeof(init_buf));
1468 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_FROM_HMODULE,
1469 test, 0, 0, out, sizeof(out)/sizeof(WCHAR), NULL);
1470 ok(ret == 4, "Expected FormatMessageW to return 4, got %u\n", ret);
1471 ok(!lstrcmpW(test, out),
1472 "Expected the output buffer to be untouched\n");
1473
1474 memcpy(out, init_buf, sizeof(init_buf));
1475 ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_FROM_HMODULE |
1476 FORMAT_MESSAGE_FROM_SYSTEM, test, 0, 0, out,
1477 sizeof(out)/sizeof(WCHAR), NULL);
1478 ok(ret == 4, "Expected FormatMessageW to return 4, got %u\n", ret);
1479 ok(!lstrcmpW(test, out),
1480 "Expected the output buffer to be untouched\n");
1481 }
1482
1483 START_TEST(format_msg)
1484 {
1485 test_message_from_string();
1486 test_message_from_string_wide();
1487 test_message_ignore_inserts();
1488 test_message_ignore_inserts_wide();
1489 test_message_insufficient_buffer();
1490 test_message_insufficient_buffer_wide();
1491 test_message_null_buffer();
1492 test_message_null_buffer_wide();
1493 test_message_allocate_buffer();
1494 test_message_allocate_buffer_wide();
1495 test_message_from_hmodule();
1496 test_message_invalid_flags();
1497 test_message_invalid_flags_wide();
1498 }
useful hacks and other patches not (yet) suitable for mainline