dlls/kernel32/tests/format_msg.c

   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 te[]          = {'t','e',0};
  57     static const WCHAR st[]          = {'s','t',0};
  58     static const WCHAR t[]           = {'t',0};
  59     static const WCHAR e[]           = {'e',0};
  60     static const WCHAR s[]           = {'s',0};
  61     static const WCHAR fmt_null[]    = {'%',0};
  62     static const WCHAR fmt_tnull[]   = {'t','e','s','t','%',0};
  63     static const WCHAR fmt_1[]       = {'%','1',0};
  64     static const WCHAR fmt_12[]      = {'%','1','%','2',0};
  65     static const WCHAR fmt_123[]     = {'%','1','%','3','%','2','%','1',0};
  66     static const WCHAR fmt_123c[]    = {'%','1','!','c','!','%','2','!','c','!','%','3','!','c','!','%','1','!','c','!',0};
  67     static const WCHAR fmt_123lc[]   = {'%','1','!','l','c','!','%','2','!','l','c','!','%','3','!','l','c','!','%','1','!','l','c','!',0};
  68     static const WCHAR fmt_123wc[]   = {'%','1','!','w','c','!','%','2','!','w','c','!','%','3','!','w','c','!','%','1','!','w','c','!',0};
  69     static const WCHAR fmt_123C[]    = {'%','1','!','C','!','%','2','!','C','!','%','3','!','C','!','%','1','!','C','!',0};
  70     static const WCHAR fmt_123d[]    = {'%','1','!','d','!','%','2','!','d','!','%','3','!','d','!',0};
  71     static const WCHAR fmt_1s[]      = {'%','1','!','s','!',0};
  72     static const WCHAR fmt_s[]       = {'%','!','s','!',0};
  73     static const WCHAR fmt_ls[]      = {'%','!','l','s','!',0};
  74     static const WCHAR fmt_ws[]      = {'%','!','w','s','!',0};
  75     static const WCHAR fmt_S[]       = {'%','!','S','!',0};
  76     static const WCHAR fmt_14d[]     = {'%','1','!','4','d','!',0};
  77     static const WCHAR fmt_14x[]     = {'%','1','!','4','x','!',0};
  78     static const WCHAR fmt_14X[]     = {'%','1','!','4','X','!',0};
  79     static const WCHAR fmt_1_4X[]    = {'%','1','!','-','4','X','!',0};
  80     static const WCHAR fmt_1_4d[]    = {'%','1','!','-','4','d','!',0};
  81     static const WCHAR fmt_2pct[]    = {' ','%','%','%','%',' ',0};
  82     static const WCHAR fmt_2dot1d[]  = {' ', '%','.','%','.',' ',' ','%','1','!','d','!',0};
  83     static const WCHAR fmt_t0t[]     = {'t','e','s','t','%','0','t','e','s','t',0};
  84     static const WCHAR fmt_yah[]     = {'y','a','h','%','!','%','0',' ',' ',' ',0};
  85     static const WCHAR fmt_space[]   = {'%',' ','%',' ',' ',' ',0};
  86     static const WCHAR fmt_hi_lf[]   = {'h','i','\n',0};
  87     static const WCHAR fmt_hi_crlf[] = {'h','i','\r','\n',0};
  88     static const WCHAR fmt_cr[]      = {'\r',0};
  89     static const WCHAR fmt_crcrlf[]  = {'\r','\r','\n',0};
  90     static const WCHAR fmt_13s[]     = {'%','1','!','3','s','!',0};
  91     static const WCHAR fmt_1os[]     = {'%','1','!','*','s','!',0};
  92     static const WCHAR fmt_142u[]    = {'%','1','!','4','.','2','u','!',0};
  93     static const WCHAR fmt_1oou[]    = {'%','1','!','*','.','*','u','!',0};
  94     static const WCHAR fmt_1oou1oou[] = {'%','1','!','*','.','*','u','!',',','%','1','!','*','.','*','u','!',0};
  95     static const WCHAR fmt_1oou3oou[] = {'%','1','!','*','.','*','u','!',',','%','3','!','*','.','*','u','!',0};
  96     static const WCHAR fmt_1oou4oou[] = {'%','1','!','*','.','*','u','!',',','%','4','!','*','.','*','u','!',0};
  97
  98     static const WCHAR s_123d[]      = {'1','2','3',0};
  99     static const WCHAR s_14d[]       = {' ',' ',' ','1',0};
 100     static const WCHAR s_14x[]       = {' ',' ',' ','b',0};
 101     static const WCHAR s_14X[]       = {' ',' ',' ','B',0};
 102     static const WCHAR s_1_4X[]      = {'B',' ',' ',' ',0};
 103     static const WCHAR s_14d2[]      = {' ',' ','1','1',0};
 104     static const WCHAR s_1_4d[]      = {'1',' ',' ',' ',0};
 105     static const WCHAR s_1AB[]       = {' ','1','A','B',0};
 106     static const WCHAR s_2pct[]      = {' ','%','%',' ',0};
 107     static const WCHAR s_2dot147[]   = {' ','.','.',' ',' ','4','2','7',0};
 108     static const WCHAR s_yah[]       = {'y','a','h','!',0};
 109     static const WCHAR s_space[]     = {' ',' ',' ',' ',0};
 110     static const WCHAR s_hi_crlf[]   = {'h','i','\r','\n',0};
 111     static const WCHAR s_crlf[]      = {'\r','\n',0};
 112     static const WCHAR s_crlfcrlf[]  = {'\r','\n','\r','\n',0};
 113     static const WCHAR s_hi_sp[]     = {'h','i',' ',0};
 114     static const WCHAR s_sp[]        = {' ',0};
 115     static const WCHAR s_2sp[]       = {' ',' ',0};
 116     static const WCHAR s_spt[]       = {' ',' ','t',0};
 117     static const WCHAR s_sp3t[]      = {' ',' ',' ','t',0};
 118     static const WCHAR s_sp03[]      = {' ',' ','0','3',0};
 119     static const WCHAR s_sp001[]     = {' ',' ','0','0','1',0};
 120     static const WCHAR s_sp001002[]  = {' ',' ','0','0','1',',',' ','0','0','0','2',0};
 121     static const WCHAR s_sp001sp002[] = {' ',' ','0','0','1',',',' ',' ','0','0','0','2',0};
 122     static const WCHAR s_sp002sp001[] = {' ',' ','0','0','0','2',',',' ',' ','0','0','1',0};
 123     static const WCHAR s_sp002sp003[] = {' ',' ','0','0','0','2',',',' ','0','0','0','0','3',0};
 124     static const WCHAR s_sp001004[]   = {' ',' ','0','0','1',',','0','0','0','0','0','4',0};
 125
 126     static const WCHAR init_buf[] = {'x', 'x', 'x', 'x', 'x', 'x'};
 127     static const WCHAR broken_buf[] = {'t','e','s','t','x','x'};
 128
 129     WCHAR out[0x100] = {0};
 130     DWORD r, error;
 131
 132     SetLastError(0xdeadbeef);
 133     r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
 134     error = GetLastError();
 135     if (!r && error == ERROR_CALL_NOT_IMPLEMENTED)
 136     {
 137         win_skip("FormatMessageW is not implemented\n");
 138         return;
 139     }
 140
 141     /* the basics */
 142     r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0,
 143         0, out, sizeof(out)/sizeof(WCHAR), NULL);
 144     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 145     ok(r==4, "failed: r=%d\n", r);
 146
 147     /* format placeholder with no specifier */
 148     SetLastError(0xdeadbeef);
 149     memcpy(out, init_buf, sizeof(init_buf));
 150     r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, fmt_null, 0,
 151         0, out, sizeof(out)/sizeof(WCHAR), NULL);
 152     error = GetLastError();
 153     ok(!memcmp(out, init_buf, sizeof(init_buf)),
 154        "Expected the buffer to be unchanged\n");
 155     ok(r==0, "succeeded: r=%d\n", r);
 156     ok(error==ERROR_INVALID_PARAMETER, "last error %u\n", error);
 157
 158     /* test string with format placeholder with no specifier */
 159     SetLastError(0xdeadbeef);
 160     memcpy(out, init_buf, sizeof(init_buf));
 161     r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, fmt_tnull, 0,
 162         0, out, sizeof(out)/sizeof(WCHAR), NULL);
 163     error = GetLastError();
 164     ok(!memcmp(out, init_buf, sizeof(init_buf)) ||
 165        broken(!memcmp(out, broken_buf, sizeof(broken_buf))), /* W2K3+ */
 166        "Expected the buffer to be unchanged\n");
 167     ok(r==0, "succeeded: r=%d\n", r);
 168     ok(error==ERROR_INVALID_PARAMETER, "last error %u\n", error);
 169
 170     /* using the format feature */
 171     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1s, 0,
 172         0, out, sizeof(out)/sizeof(WCHAR), test);
 173     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 174     ok(r==4,"failed: r=%d\n", r);
 175
 176     /* no format */
 177     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1, 0,
 178         0, out, sizeof(out)/sizeof(WCHAR), test);
 179     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 180     ok(r==4,"failed: r=%d\n", r);
 181
 182     /* two pieces */
 183     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_12, 0,
 184         0, out, sizeof(out)/sizeof(WCHAR), te, st);
 185     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 186     ok(r==4,"failed: r=%d\n", r);
 187
 188     /* three pieces */
 189     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123, 0,
 190         0, out, sizeof(out)/sizeof(WCHAR), t, s, e);
 191     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 192     ok(r==4,"failed: r=%d\n", r);
 193
 194     /* s doesn't seem to work in format strings */
 195     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_s, 0,
 196         0, out, sizeof(out)/sizeof(WCHAR), test);
 197     ok(!lstrcmpW(&fmt_s[1], out), "failed out=%s\n", wine_dbgstr_w(out));
 198     ok(r==3, "failed: r=%d\n", r);
 199
 200     /* nor ls */
 201     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_ls, 0,
 202         0, out, sizeof(out)/sizeof(WCHAR), test);
 203     ok(!lstrcmpW(&fmt_ls[1], out), "failed out=%s\n", wine_dbgstr_w(out));
 204     ok(r==4, "failed: r=%d\n", r);
 205
 206     /* nor S */
 207     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_S, 0,
 208         0, out, sizeof(out)/sizeof(WCHAR), test);
 209     ok(!lstrcmpW(&fmt_S[1], out), "failed out=%s\n", wine_dbgstr_w(out));
 210     ok(r==3, "failed: r=%d\n", r);
 211
 212     /* nor ws */
 213     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_ws, 0,
 214         0, out, sizeof(out)/sizeof(WCHAR), test);
 215     ok(!lstrcmpW(&fmt_ws[1], out), "failed out=%s\n", wine_dbgstr_w(out));
 216     ok(r==4, "failed: r=%d\n", r);
 217
 218     /* as characters */
 219     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123c, 0,
 220         0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
 221     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 222     ok(r==4,"failed: r=%d\n", r);
 223
 224     /* lc is unicode */
 225     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123lc, 0,
 226         0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
 227     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 228     ok(r==4,"failed: r=%d\n", r);
 229
 230     /* wc is unicode */
 231     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123wc, 0,
 232         0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
 233     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 234     ok(r==4,"failed: r=%d\n", r);
 235
 236     /* C is unicode */
 237     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123C, 0,
 238         0, out, sizeof(out)/sizeof(WCHAR), 't', 'e', 's');
 239     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 240     ok(r==4,"failed: r=%d\n", r);
 241
 242     /* some numbers */
 243     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_123d, 0,
 244         0, out, sizeof(out)/sizeof(WCHAR), 1, 2, 3);
 245     ok(!lstrcmpW(s_123d, out), "failed out=%s\n", wine_dbgstr_w(out));
 246     ok(r==3,"failed: r=%d\n", r);
 247
 248     /* a single digit with some spacing */
 249     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14d, 0,
 250         0, out, sizeof(out)/sizeof(WCHAR), 1);
 251     ok(!lstrcmpW(s_14d, out), "failed out=%s\n", wine_dbgstr_w(out));
 252
 253     /* a single digit, left justified */
 254     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1_4d, 0,
 255         0, out, sizeof(out)/sizeof(CHAR), 1);
 256     ok(!lstrcmpW(s_1_4d, out), "failed out=%s\n", wine_dbgstr_w(out));
 257     ok(r==4,"failed: r=%d\n", r);
 258
 259     /* two digit decimal number */
 260     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14d, 0,
 261         0, out, sizeof(out)/sizeof(WCHAR), 11);
 262     ok(!lstrcmpW(s_14d2, out), "failed out=%s\n", wine_dbgstr_w(out));
 263     ok(r==4,"failed: r=%d\n", r);
 264
 265     /* a hex number */
 266     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14x, 0,
 267         0, out, sizeof(out)/sizeof(WCHAR), 11);
 268     ok(!lstrcmpW(s_14x, out), "failed out=%s\n", wine_dbgstr_w(out));
 269     ok(r==4,"failed: r=%d\n", r);
 270
 271     /* a hex number, upper case */
 272     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14X, 0,
 273         0, out, sizeof(out)/sizeof(WCHAR), 11);
 274     ok(!lstrcmpW(s_14X, out), "failed out=%s\n", wine_dbgstr_w(out));
 275     ok(r==4,"failed: r=%d\n", r);
 276
 277     /* a hex number, upper case, left justified */
 278     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1_4X, 0,
 279         0, out, sizeof(out)/sizeof(WCHAR), 11);
 280     ok(!lstrcmpW(s_1_4X, out), "failed out=%s\n", wine_dbgstr_w(out));
 281     ok(r==4,"failed: r=%d\n", r);
 282
 283     /* a long hex number, upper case */
 284     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_14X, 0,
 285         0, out, sizeof(out)/sizeof(WCHAR), 0x1ab);
 286     ok(!lstrcmpW(s_1AB, out), "failed out=%s\n", wine_dbgstr_w(out));
 287     ok(r==4,"failed: r=%d\n", r);
 288
 289     /* two percent... */
 290     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_2pct, 0,
 291         0, out, sizeof(out)/sizeof(WCHAR));
 292     ok(!lstrcmpW(s_2pct, out), "failed out=%s\n", wine_dbgstr_w(out));
 293     ok(r==4,"failed: r=%d\n", r);
 294
 295     /* periods are special cases */
 296     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_2dot1d, 0,
 297         0, out, sizeof(out)/sizeof(WCHAR), 0x1ab);
 298     ok(!lstrcmpW(s_2dot147, out), "failed out=%s\n", wine_dbgstr_w(out));
 299     ok(r==8,"failed: r=%d\n", r);
 300
 301     /* %0 ends the line */
 302     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_t0t, 0,
 303         0, out, sizeof(out)/sizeof(WCHAR));
 304     ok(!lstrcmpW(test, out), "failed out=%s\n", wine_dbgstr_w(out));
 305     ok(r==4,"failed: r=%d\n", r);
 306
 307     /* %! prints an exclamation */
 308     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_yah, 0,
 309         0, out, sizeof(out)/sizeof(WCHAR));
 310     ok(!lstrcmpW(s_yah, out), "failed out=%s\n", wine_dbgstr_w(out));
 311     ok(r==4,"failed: r=%d\n", r);
 312
 313     /* %space */
 314     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_space, 0,
 315         0, out, sizeof(out)/sizeof(WCHAR));
 316     ok(!lstrcmpW(s_space, out), "failed out=%s\n", wine_dbgstr_w(out));
 317     ok(r==4,"failed: r=%d\n", r);
 318
 319     /* line feed */
 320     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_hi_lf, 0,
 321         0, out, sizeof(out)/sizeof(WCHAR));
 322     ok(!lstrcmpW(s_hi_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
 323     ok(r==4,"failed: r=%d\n", r);
 324
 325     /* carriage return line feed */
 326     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_hi_crlf, 0,
 327         0, out, sizeof(out)/sizeof(WCHAR));
 328     ok(!lstrcmpW(s_hi_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
 329     ok(r==4,"failed: r=%d\n", r);
 330
 331     /* carriage return */
 332     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_cr, 0,
 333         0, out, sizeof(out)/sizeof(WCHAR));
 334     ok(!lstrcmpW(s_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
 335     ok(r==2,"failed: r=%d\n", r);
 336
 337     /* double carriage return line feed */
 338     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_crcrlf, 0,
 339         0, out, sizeof(out)/sizeof(WCHAR));
 340     ok(!lstrcmpW(s_crlfcrlf, out), "failed out=%s\n", wine_dbgstr_w(out));
 341     ok(r==4,"failed: r=%d\n", r);
 342
 343     /* precision and width */
 344
 345     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_13s,
 346               0, 0, out, sizeof(out)/sizeof(WCHAR), t );
 347     ok(!lstrcmpW(s_spt, out),"failed out=[%s]\n", wine_dbgstr_w(out));
 348     ok(r==3, "failed: r=%d\n",r);
 349     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1os,
 350               0, 0, out, sizeof(out)/sizeof(WCHAR), 4, t );
 351     ok(!lstrcmpW( s_sp3t, out),"failed out=[%s]\n", wine_dbgstr_w(out));
 352     ok(r==4,"failed: r=%d\n",r);
 353     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_142u,
 354               0, 0, out, sizeof(out)/sizeof(WCHAR), 3 );
 355     ok(!lstrcmpW( s_sp03, out),"failed out=[%s]\n", wine_dbgstr_w(out));
 356     ok(r==4,"failed: r=%d\n",r);
 357     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1oou,
 358               0, 0, out, sizeof(out)/sizeof(WCHAR), 5, 3, 1 );
 359     ok(!lstrcmpW( s_sp001, out),"failed out=[%s]\n", wine_dbgstr_w(out));
 360     ok(r==5,"failed: r=%d\n",r);
 361     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1oou1oou,
 362               0, 0, out, sizeof(out)/sizeof(WCHAR), 5, 3, 1, 4, 2 );
 363     ok(!lstrcmpW( s_sp001002, out),"failed out=[%s]\n", wine_dbgstr_w(out));
 364     ok(r==11,"failed: r=%d\n",r);
 365     r = doitW(FORMAT_MESSAGE_FROM_STRING, fmt_1oou3oou,
 366               0, 0, out, sizeof(out)/sizeof(WCHAR), 5, 3, 1, 6, 4, 2 );
 367     ok(!lstrcmpW( s_sp001sp002, out) || broken(!lstrcmpW(s_sp001004, out)),
 368        "failed out=[%s]\n", wine_dbgstr_w(out));
 369     ok(r==12,"failed: r=%d\n",r);
 370     /* args are not counted the same way with an argument array */
 371     {
 372         ULONG_PTR args[] = { 6, 4, 2, 5, 3, 1 };
 373         r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, fmt_1oou1oou,
 374                            0, 0, out, sizeof(out)/sizeof(WCHAR), (__ms_va_list *)args );
 375         ok(!lstrcmpW(s_sp002sp003, out),"failed out=[%s]\n", wine_dbgstr_w(out));
 376         ok(r==13,"failed: r=%d\n",r);
 377         r = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, fmt_1oou4oou,
 378                            0, 0, out, sizeof(out)/sizeof(WCHAR), (__ms_va_list *)args );
 379         ok(!lstrcmpW(s_sp002sp001, out),"failed out=[%s]\n", wine_dbgstr_w(out));
 380         ok(r==12,"failed: r=%d\n",r);
 381     }
 382
 383     /* change of pace... test the low byte of dwflags */
 384
 385     /* line feed */
 386     r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_hi_lf, 0,
 387         0, out, sizeof(out)/sizeof(WCHAR));
 388     ok(!lstrcmpW(s_hi_sp, out) || !lstrcmpW(s_hi_crlf, out), "failed out=%s\n", wine_dbgstr_w(out));
 389     ok(r==3 || r==4,"failed: r=%d\n", r);
 390
 391     /* carriage return line feed */
 392     r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_hi_crlf, 0,
 393         0, out, sizeof(out)/sizeof(WCHAR));
 394     ok(!lstrcmpW(s_hi_sp, out), "failed out=%s\n", wine_dbgstr_w(out));
 395     ok(r==3,"failed: r=%d\n", r);
 396
 397     /* carriage return */
 398     r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_cr, 0,
 399         0, out, sizeof(out)/sizeof(WCHAR));
 400     ok(!lstrcmpW(s_sp, out), "failed out=%s\n", wine_dbgstr_w(out));
 401     ok(r==1,"failed: r=%d\n", r);
 402
 403     /* double carriage return line feed */
 404     r = doitW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, fmt_crcrlf, 0,
 405         0, out, sizeof(out)/sizeof(WCHAR));
 406     ok(!lstrcmpW(s_2sp, out), "failed out=%s\n", wine_dbgstr_w(out));
 407     ok(r==2,"failed: r=%d\n", r);
 408 }
 409
 410 static void test_message_from_string(void)
 411 {
 412     CHAR out[0x100] = {0};
 413     DWORD r;
 414     static const char init_buf[] = {'x', 'x', 'x', 'x', 'x', 'x'};
 415     static const WCHAR szwTest[] = { 't','e','s','t',0};
 416
 417     /* the basics */
 418     r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0,
 419         0, out, sizeof(out)/sizeof(CHAR),NULL);
 420     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 421     ok(r==4,"failed: r=%d\n",r);
 422
 423     /* format placeholder with no specifier */
 424     SetLastError(0xdeadbeef);
 425     memcpy(out, init_buf, sizeof(init_buf));
 426     r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "%", 0,
 427         0, out, sizeof(out)/sizeof(CHAR), NULL);
 428     ok(!memcmp(out, init_buf, sizeof(init_buf)),
 429        "Expected the buffer to be untouched\n");
 430     ok(r==0, "succeeded: r=%d\n", r);
 431     ok(GetLastError()==ERROR_INVALID_PARAMETER,
 432        "last error %u\n", GetLastError());
 433
 434     /* test string with format placeholder with no specifier */
 435     SetLastError(0xdeadbeef);
 436     memcpy(out, init_buf, sizeof(init_buf));
 437     r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test%", 0,
 438         0, out, sizeof(out)/sizeof(CHAR), NULL);
 439     ok(!memcmp(out, init_buf, sizeof(init_buf)),
 440        "Expected the buffer to be untouched\n");
 441     ok(r==0, "succeeded: r=%d\n", r);
 442     ok(GetLastError()==ERROR_INVALID_PARAMETER,
 443        "last error %u\n", GetLastError());
 444
 445     /* using the format feature */
 446     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!s!", 0,
 447         0, out, sizeof(out)/sizeof(CHAR), "test");
 448     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 449     ok(r==4,"failed: r=%d\n",r);
 450
 451     /* no format */
 452     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1", 0,
 453         0, out, sizeof(out)/sizeof(CHAR), "test");
 454     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 455     ok(r==4,"failed: r=%d\n",r);
 456
 457     /* two pieces */
 458     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1%2", 0,
 459         0, out, sizeof(out)/sizeof(CHAR), "te","st");
 460     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 461     ok(r==4,"failed: r=%d\n",r);
 462
 463     /* three pieces */
 464     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1%3%2%1", 0,
 465         0, out, sizeof(out)/sizeof(CHAR), "t","s","e");
 466     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 467     ok(r==4,"failed: r=%d\n",r);
 468
 469     /* s doesn't seem to work in format strings */
 470     r = doit(FORMAT_MESSAGE_FROM_STRING, "%!s!", 0,
 471         0, out, sizeof(out)/sizeof(CHAR), "test");
 472     ok(!strcmp("!s!", out),"failed out=[%s]\n",out);
 473     ok(r==3,"failed: r=%d\n",r);
 474
 475     /* ls is unicode */
 476     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!ls!", 0,
 477         0, out, sizeof(out)/sizeof(CHAR), szwTest);
 478     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 479     ok(r==4,"failed: r=%d\n",r);
 480
 481     /* S is unicode */
 482     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!S!", 0,
 483         0, out, sizeof(out)/sizeof(CHAR), szwTest);
 484     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 485     ok(r==4,"failed: r=%d\n",r);
 486
 487     /* ws is unicode */
 488     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!ws!", 0,
 489         0, out, sizeof(out)/sizeof(CHAR), szwTest);
 490     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 491     ok(r==4,"failed: r=%d\n",r);
 492
 493     /* as characters */
 494     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!c!%2!c!%3!c!%1!c!", 0,
 495         0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
 496     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 497     ok(r==4,"failed: r=%d\n",r);
 498
 499     /* lc is unicode */
 500     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!lc!%2!lc!%3!lc!%1!lc!", 0,
 501         0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
 502     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 503     ok(r==4,"failed: r=%d\n",r);
 504
 505     /* wc is unicode */
 506     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!wc!%2!wc!%3!wc!%1!wc!", 0,
 507         0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
 508     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 509     ok(r==4,"failed: r=%d\n",r);
 510
 511     /* C is unicode */
 512     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!C!%2!C!%3!C!%1!C!", 0,
 513         0, out, sizeof(out)/sizeof(CHAR), 't','e','s');
 514     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 515     ok(r==4,"failed: r=%d\n",r);
 516
 517     /* some numbers */
 518     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!d!%2!d!%3!d!", 0,
 519         0, out, sizeof(out)/sizeof(CHAR), 1,2,3);
 520     ok(!strcmp("123", out),"failed out=[%s]\n",out);
 521     ok(r==3,"failed: r=%d\n",r);
 522
 523     /* a single digit with some spacing */
 524     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4d!", 0,
 525         0, out, sizeof(out)/sizeof(CHAR), 1);
 526     ok(!strcmp("   1", out),"failed out=[%s]\n",out);
 527     ok(r==4,"failed: r=%d\n",r);
 528
 529     /* a single digit, left justified */
 530     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!-4d!", 0,
 531         0, out, sizeof(out)/sizeof(CHAR), 1);
 532     ok(!strcmp("1   ", out),"failed out=[%s]\n",out);
 533     ok(r==4,"failed: r=%d\n",r);
 534
 535     /* two digit decimal number */
 536     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4d!", 0,
 537         0, out, sizeof(out)/sizeof(CHAR), 11);
 538     ok(!strcmp("  11", out),"failed out=[%s]\n",out);
 539     ok(r==4,"failed: r=%d\n",r);
 540
 541     /* a hex number */
 542     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4x!", 0,
 543         0, out, sizeof(out)/sizeof(CHAR), 11);
 544     ok(!strcmp("   b", out),"failed out=[%s]\n",out);
 545     ok(r==4,"failed: r=%d\n",r);
 546
 547     /* a hex number, upper case */
 548     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4X!", 0,
 549         0, out, sizeof(out)/sizeof(CHAR), 11);
 550     ok(!strcmp("   B", out),"failed out=[%s]\n",out);
 551     ok(r==4,"failed: r=%d\n",r);
 552
 553     /* a hex number, upper case, left justified */
 554     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!-4X!", 0,
 555         0, out, sizeof(out)/sizeof(CHAR), 11);
 556     ok(!strcmp("B   ", out),"failed out=[%s]\n",out);
 557     ok(r==4,"failed: r=%d\n",r);
 558
 559     /* a long hex number, upper case */
 560     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4X!", 0,
 561         0, out, sizeof(out)/sizeof(CHAR), 0x1ab);
 562     ok(!strcmp(" 1AB", out),"failed out=[%s]\n",out);
 563     ok(r==4,"failed: r=%d\n",r);
 564
 565     /* two percent... */
 566     r = doit(FORMAT_MESSAGE_FROM_STRING, " %%%% ", 0,
 567         0, out, sizeof(out)/sizeof(CHAR));
 568     ok(!strcmp(" %% ", out),"failed out=[%s]\n",out);
 569     ok(r==4,"failed: r=%d\n",r);
 570
 571     /* periods are special cases */
 572     r = doit(FORMAT_MESSAGE_FROM_STRING, " %.%. %1!d!", 0,
 573         0, out, sizeof(out)/sizeof(CHAR), 0x1ab);
 574     ok(!strcmp(" .. 427", out),"failed out=[%s]\n",out);
 575     ok(r==7,"failed: r=%d\n",r);
 576
 577     /* %0 ends the line */
 578     r = doit(FORMAT_MESSAGE_FROM_STRING, "test%0test", 0,
 579         0, out, sizeof(out)/sizeof(CHAR));
 580     ok(!strcmp("test", out),"failed out=[%s]\n",out);
 581     ok(r==4,"failed: r=%d\n",r);
 582
 583     /* %! prints an exclamation */
 584     r = doit(FORMAT_MESSAGE_FROM_STRING, "yah%!%0   ", 0,
 585         0, out, sizeof(out)/sizeof(CHAR));
 586     ok(!strcmp("yah!", out),"failed out=[%s]\n",out);
 587     ok(r==4,"failed: r=%d\n",r);
 588
 589     /* %space */
 590     r = doit(FORMAT_MESSAGE_FROM_STRING, "% %   ", 0,
 591         0, out, sizeof(out)/sizeof(CHAR));
 592     ok(!strcmp("    ", out),"failed out=[%s]\n",out);
 593     ok(r==4,"failed: r=%d\n",r);
 594
 595     /* line feed */
 596     r = doit(FORMAT_MESSAGE_FROM_STRING, "hi\n", 0,
 597         0, out, sizeof(out)/sizeof(CHAR));
 598     ok(!strcmp("hi\r\n", out),"failed out=[%s]\n",out);
 599     ok(r==4,"failed: r=%d\n",r);
 600
 601     /* carriage return line feed */
 602     r = doit(FORMAT_MESSAGE_FROM_STRING, "hi\r\n", 0,
 603         0, out, sizeof(out)/sizeof(CHAR));
 604     ok(!strcmp("hi\r\n", out),"failed out=[%s]\n",out);
 605     ok(r==4,"failed: r=%d\n",r);
 606
 607     /* carriage return */
 608     r = doit(FORMAT_MESSAGE_FROM_STRING, "\r", 0,
 609         0, out, sizeof(out)/sizeof(CHAR));
 610     ok(!strcmp("\r\n", out),"failed out=[%s]\n",out);
 611     ok(r==2,"failed: r=%d\n",r);
 612
 613     /* double carriage return line feed */
 614     r = doit(FORMAT_MESSAGE_FROM_STRING, "\r\r\n", 0,
 615         0, out, sizeof(out)/sizeof(CHAR));
 616     ok(!strcmp("\r\n\r\n", out),"failed out=[%s]\n",out);
 617     ok(r==4,"failed: r=%d\n",r);
 618
 619     /* precision and width */
 620
 621     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!3s!",
 622              0, 0, out, sizeof(out), "t" );
 623     ok(!strcmp("  t", out),"failed out=[%s]\n",out);
 624     ok(r==3, "failed: r=%d\n",r);
 625     r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*s!",
 626              0, 0, out, sizeof(out), 4, "t");
 627     if (!strcmp("*s",out)) win_skip( "width/precision not supported\n" );
 628     else
 629     {
 630         ok(!strcmp( "   t", out),"failed out=[%s]\n",out);
 631         ok(r==4,"failed: r=%d\n",r);
 632         r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!4.2u!",
 633                  0, 0, out, sizeof(out), 3 );
 634         ok(!strcmp( "  03", out),"failed out=[%s]\n",out);
 635         ok(r==4,"failed: r=%d\n",r);
 636         r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*.*u!",
 637                  0, 0, out, sizeof(out), 5, 3, 1 );
 638         ok(!strcmp( "  001", out),"failed out=[%s]\n",out);
 639         ok(r==5,"failed: r=%d\n",r);
 640         r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*.*u!,%1!*.*u!",
 641                  0, 0, out, sizeof(out), 5, 3, 1, 4, 2 );
 642         ok(!strcmp( "  001, 0002", out),"failed out=[%s]\n",out);
 643         ok(r==11,"failed: r=%d\n",r);
 644         r = doit(FORMAT_MESSAGE_FROM_STRING, "%1!*.*u!,%3!*.*u!",
 645                  0, 0, out, sizeof(out), 5, 3, 1, 6, 4, 2 );
 646         /* older Win versions marked as broken even though this is arguably the correct behavior */
 647         /* but the new (brain-damaged) behavior is specified on MSDN */
 648         ok(!strcmp( "  001,  0002", out) || broken(!strcmp("  001,000004", out)),
 649            "failed out=[%s]\n",out);
 650         ok(r==12,"failed: r=%d\n",r);
 651         /* args are not counted the same way with an argument array */
 652         {
 653             ULONG_PTR args[] = { 6, 4, 2, 5, 3, 1 };
 654             r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 655                                "%1!*.*u!,%1!*.*u!", 0, 0, out, sizeof(out), (__ms_va_list *)args );
 656             ok(!strcmp("  0002, 00003", out),"failed out=[%s]\n",out);
 657             ok(r==13,"failed: r=%d\n",r);
 658             r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 659                                "%1!*.*u!,%4!*.*u!", 0, 0, out, sizeof(out), (__ms_va_list *)args );
 660             ok(!strcmp("  0002,  001", out),"failed out=[%s]\n",out);
 661             ok(r==12,"failed: r=%d\n",r);
 662         }
 663     }
 664
 665     /* change of pace... test the low byte of dwflags */
 666
 667     /* line feed */
 668     r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "hi\n", 0,
 669         0, out, sizeof(out)/sizeof(CHAR));
 670     ok(!strcmp("hi ", out) || !strcmp("hi\r\n", out),"failed out=[%s]\n",out);
 671     ok(r==3 || r==4,"failed: r=%d\n",r);
 672
 673     /* carriage return line feed */
 674     r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "hi\r\n", 0,
 675         0, out, sizeof(out)/sizeof(CHAR));
 676     ok(!strcmp("hi ", out),"failed out=[%s]\n",out);
 677     ok(r==3,"failed: r=%d\n",r);
 678
 679     /* carriage return */
 680     r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "\r", 0,
 681         0, out, sizeof(out)/sizeof(CHAR));
 682     ok(!strcmp(" ", out),"failed out=[%s]\n",out);
 683     ok(r==1,"failed: r=%d\n",r);
 684
 685     /* double carriage return line feed */
 686     r = doit(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_MAX_WIDTH_MASK, "\r\r\n", 0,
 687         0, out, sizeof(out)/sizeof(CHAR));
 688     ok(!strcmp("  ", out),"failed out=[%s]\n",out);
 689     ok(r==2,"failed: r=%d\n",r);
 690 }
 691
 692 static void test_message_insufficient_buffer(void)
 693 {
 694     static const char init_buf[] = {'x', 'x', 'x', 'x', 'x'};
 695     static const char expected_buf[] = {'x', 'x', 'x', 'x', 'x'};
 696     DWORD ret;
 697     CHAR out[5];
 698
 699     SetLastError(0xdeadbeef);
 700     memcpy(out, init_buf, sizeof(init_buf));
 701     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0, 0, out, 0, NULL);
 702     ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
 703     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 704        "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
 705        GetLastError());
 706     ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
 707        "Expected the buffer to be untouched\n");
 708
 709     SetLastError(0xdeadbeef);
 710     memcpy(out, init_buf, sizeof(init_buf));
 711     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0, 0, out, 1, NULL);
 712     ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
 713     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 714        "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
 715        GetLastError());
 716     ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
 717        "Expected the buffer to be untouched\n");
 718
 719     SetLastError(0xdeadbeef);
 720     memcpy(out, init_buf, sizeof(init_buf));
 721     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0, 0, out, sizeof(out)/sizeof(out[0]) - 1, NULL);
 722     ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
 723     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 724        "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
 725        GetLastError());
 726     ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
 727        "Expected the buffer to be untouched\n");
 728 }
 729
 730 static void test_message_insufficient_buffer_wide(void)
 731 {
 732     static const WCHAR test[] = {'t','e','s','t',0};
 733     static const WCHAR init_buf[] = {'x', 'x', 'x', 'x', 'x'};
 734     static const WCHAR expected_buf[] = {'x', 'x', 'x', 'x', 'x'};
 735     static const WCHAR broken_buf[] = {0, 'x', 'x', 'x', 'x'};
 736     static const WCHAR broken2_buf[] = {'t','e','s',0,'x'};
 737
 738     DWORD ret;
 739     WCHAR out[5];
 740
 741     SetLastError(0xdeadbeef);
 742     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
 743     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 744     {
 745         win_skip("FormatMessageW is not implemented\n");
 746         return;
 747     }
 748
 749     SetLastError(0xdeadbeef);
 750     memcpy(out, init_buf, sizeof(init_buf));
 751     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0, 0, out, 0, NULL);
 752     ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
 753     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 754        "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
 755        GetLastError());
 756     ok(!memcmp(expected_buf, out, sizeof(expected_buf)),
 757        "Expected the buffer to be untouched\n");
 758
 759     /* Windows Server 2003 and newer report failure but copy a
 760      * truncated string to the buffer for non-zero buffer sizes. */
 761     SetLastError(0xdeadbeef);
 762     memcpy(out, init_buf, sizeof(init_buf));
 763     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0, 0, out, 1, NULL);
 764     ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
 765     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 766        "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
 767        GetLastError());
 768     ok(!memcmp(expected_buf, out, sizeof(expected_buf)) ||
 769        broken(!memcmp(broken_buf, out, sizeof(broken_buf))), /* W2K3+ */
 770        "Expected the buffer to be untouched\n");
 771
 772     SetLastError(0xdeadbeef);
 773     memcpy(out, init_buf, sizeof(init_buf));
 774     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, test, 0, 0, out, sizeof(out)/sizeof(out[0]) - 1, NULL);
 775     ok(ret == 0, "Expected FormatMessageA to return 0, got %u\n", ret);
 776     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 777        "Expected GetLastError() to return ERROR_INSUFFICIENT_BUFFER, got %u\n",
 778        GetLastError());
 779     ok(!memcmp(expected_buf, out, sizeof(expected_buf)) ||
 780        broken(!memcmp(broken2_buf, out, sizeof(broken2_buf))), /* W2K3+ */
 781        "Expected the buffer to be untouched\n");
 782 }
 783
 784 static void test_message_null_buffer(void)
 785 {
 786     DWORD ret, error;
 787
 788     /* Without FORMAT_MESSAGE_ALLOCATE_BUFFER, only the specified buffer size is checked. */
 789     SetLastError(0xdeadbeef);
 790     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 0, NULL);
 791     error = GetLastError();
 792     ok(!ret, "FormatMessageA returned %u\n", ret);
 793     ok(error == ERROR_INSUFFICIENT_BUFFER ||
 794        error == ERROR_INVALID_PARAMETER, /* win9x */
 795        "last error %u\n", error);
 796
 797     SetLastError(0xdeadbeef);
 798     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 1, NULL);
 799     error = GetLastError();
 800     ok(!ret, "FormatMessageA returned %u\n", ret);
 801     ok(error == ERROR_INSUFFICIENT_BUFFER ||
 802        error == ERROR_INVALID_PARAMETER, /* win9x */
 803        "last error %u\n", error);
 804
 805     if (0) /* crashes on Windows */
 806     {
 807         SetLastError(0xdeadbeef);
 808         ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 256, NULL);
 809         error = GetLastError();
 810         ok(!ret, "FormatMessageA returned %u\n", ret);
 811         trace("last error %u\n", error);
 812     }
 813
 814     SetLastError(0xdeadbeef);
 815     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 0, NULL);
 816     error = GetLastError();
 817     ok(!ret, "FormatMessageA returned %u\n", ret);
 818     ok(error == ERROR_NOT_ENOUGH_MEMORY ||
 819        error == ERROR_INVALID_PARAMETER, /* win9x */
 820        "last error %u\n", error);
 821
 822     SetLastError(0xdeadbeef);
 823     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 1, NULL);
 824     error = GetLastError();
 825     ok(!ret, "FormatMessageA returned %u\n", ret);
 826     ok(error == ERROR_NOT_ENOUGH_MEMORY ||
 827        error == ERROR_INVALID_PARAMETER, /* win9x */
 828        "last error %u\n", error);
 829
 830     SetLastError(0xdeadbeef);
 831     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 256, NULL);
 832     error = GetLastError();
 833     ok(!ret, "FormatMessageA returned %u\n", ret);
 834     ok(error == ERROR_NOT_ENOUGH_MEMORY ||
 835        error == ERROR_INVALID_PARAMETER, /* win9x */
 836        "last error %u\n", error);
 837 }
 838
 839 static void test_message_null_buffer_wide(void)
 840 {
 841     DWORD ret, error;
 842
 843     SetLastError(0xdeadbeef);
 844     ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 0, NULL);
 845     error = GetLastError();
 846     if (!ret && error == ERROR_CALL_NOT_IMPLEMENTED)
 847     {
 848         win_skip("FormatMessageW is not implemented\n");
 849         return;
 850     }
 851
 852     SetLastError(0xdeadbeef);
 853     ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 0, NULL);
 854     error = GetLastError();
 855     ok(!ret, "FormatMessageW returned %u\n", ret);
 856     ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
 857
 858     SetLastError(0xdeadbeef);
 859     ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 1, NULL);
 860     error = GetLastError();
 861     ok(!ret, "FormatMessageW returned %u\n", ret);
 862     ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
 863
 864     SetLastError(0xdeadbeef);
 865     ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 0, 0, NULL, 256, NULL);
 866     error = GetLastError();
 867     ok(!ret, "FormatMessageW returned %u\n", ret);
 868     ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
 869
 870     SetLastError(0xdeadbeef);
 871     ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 0, NULL);
 872     error = GetLastError();
 873     ok(!ret, "FormatMessageW returned %u\n", ret);
 874     ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
 875
 876     SetLastError(0xdeadbeef);
 877     ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 1, NULL);
 878     error = GetLastError();
 879     ok(!ret, "FormatMessageW returned %u\n", ret);
 880     ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
 881
 882     SetLastError(0xdeadbeef);
 883     ret = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, 0, 0, NULL, 256, NULL);
 884     error = GetLastError();
 885     ok(!ret, "FormatMessageW returned %u\n", ret);
 886     ok(error == ERROR_INVALID_PARAMETER, "last error %u\n", error);
 887 }
 888
 889 static void test_message_allocate_buffer(void)
 890 {
 891     DWORD ret;
 892     char *buf;
 893
 894     /* While MSDN suggests that FormatMessageA allocates a buffer whose size is
 895      * the larger of the output string and the requested buffer size, the tests
 896      * will not try to determine the actual size of the buffer allocated, as
 897      * the return value of LocalSize cannot be trusted for the purpose, and it should
 898      * in any case be safe for FormatMessageA to allocate in the manner that
 899      * MSDN suggests. */
 900
 901     buf = (char *)0xdeadbeef;
 902     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 903                          "test", 0, 0, (char *)&buf, 0, NULL);
 904     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
 905     ok(buf != NULL && buf != (char *)0xdeadbeef,
 906        "Expected output buffer pointer to be valid\n");
 907     if (buf != NULL && buf != (char *)0xdeadbeef)
 908     {
 909         ok(!strcmp("test", buf),
 910            "Expected buffer to contain \"test\", got %s\n", buf);
 911         LocalFree(buf);
 912     }
 913
 914     buf = (char *)0xdeadbeef;
 915     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 916                          "test", 0, 0, (char *)&buf, strlen("test"), NULL);
 917     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
 918     ok(buf != NULL && buf != (char *)0xdeadbeef,
 919        "Expected output buffer pointer to be valid\n");
 920     if (buf != NULL && buf != (char *)0xdeadbeef)
 921     {
 922         ok(!strcmp("test", buf),
 923            "Expected buffer to contain \"test\", got %s\n", buf);
 924         LocalFree(buf);
 925     }
 926
 927     buf = (char *)0xdeadbeef;
 928     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 929                          "test", 0, 0, (char *)&buf, strlen("test") + 1, NULL);
 930     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
 931     ok(buf != NULL && buf != (char *)0xdeadbeef,
 932        "Expected output buffer pointer to be valid\n");
 933    if (buf != NULL && buf != (char *)0xdeadbeef)
 934     {
 935         ok(!strcmp("test", buf),
 936            "Expected buffer to contain \"test\", got %s\n", buf);
 937         LocalFree(buf);
 938     }
 939
 940     buf = (char *)0xdeadbeef;
 941     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 942                          "test", 0, 0, (char *)&buf, strlen("test") + 2, NULL);
 943     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
 944     ok(buf != NULL && buf != (char *)0xdeadbeef,
 945        "Expected output buffer pointer to be valid\n");
 946     if (buf != NULL && buf != (char *)0xdeadbeef)
 947     {
 948         ok(!strcmp("test", buf),
 949            "Expected buffer to contain \"test\", got %s\n", buf);
 950         LocalFree(buf);
 951     }
 952
 953     buf = (char *)0xdeadbeef;
 954     ret = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 955                          "test", 0, 0, (char *)&buf, 1024, NULL);
 956     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
 957     ok(buf != NULL && buf != (char *)0xdeadbeef,
 958        "Expected output buffer pointer to be valid\n");
 959     if (buf != NULL && buf != (char *)0xdeadbeef)
 960     {
 961         ok(!strcmp("test", buf),
 962            "Expected buffer to contain \"test\", got %s\n", buf);
 963         LocalFree(buf);
 964     }
 965 }
 966
 967 static void test_message_allocate_buffer_wide(void)
 968 {
 969     static const WCHAR test[] = {'t','e','s','t',0};
 970
 971     DWORD ret;
 972     WCHAR *buf;
 973
 974     SetLastError(0xdeadbeef);
 975     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, NULL, 0, 0, NULL, 0, NULL);
 976     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 977     {
 978         win_skip("FormatMessageW is not implemented\n");
 979         return;
 980     }
 981
 982     /* While MSDN suggests that FormatMessageA allocates a buffer whose size is
 983      * the larger of the output string and the requested buffer size, the tests
 984      * will not try to determine the actual size of the buffer allocated, as
 985      * the return value of LocalSize cannot be trusted for the purpose, and it should
 986      * in any case be safe for FormatMessageA to allocate in the manner that
 987      * MSDN suggests. */
 988
 989     buf = (WCHAR *)0xdeadbeef;
 990     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 991                          test, 0, 0, (WCHAR *)&buf, 0, NULL);
 992     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
 993     ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
 994        "Expected output buffer pointer to be valid\n");
 995     if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
 996     {
 997         ok(!lstrcmpW(test, buf),
 998            "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
 999         LocalFree(buf);
1000     }
1001
1002     buf = (WCHAR *)0xdeadbeef;
1003     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1004                          test, 0, 0, (WCHAR *)&buf, sizeof(test)/sizeof(WCHAR) - 1, NULL);
1005     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1006     ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1007        "Expected output buffer pointer to be valid\n");
1008     if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1009     {
1010         ok(!lstrcmpW(test, buf),
1011            "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1012         LocalFree(buf);
1013     }
1014
1015     buf = (WCHAR *)0xdeadbeef;
1016     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1017                          test, 0, 0, (WCHAR *)&buf, sizeof(test)/sizeof(WCHAR), NULL);
1018     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1019     ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1020        "Expected output buffer pointer to be valid\n");
1021     if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1022     {
1023         ok(!lstrcmpW(test, buf),
1024            "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1025         LocalFree(buf);
1026     }
1027
1028     buf = (WCHAR *)0xdeadbeef;
1029     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1030                          test, 0, 0, (WCHAR *)&buf, sizeof(test)/sizeof(WCHAR) + 1, NULL);
1031     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1032     ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1033        "Expected output buffer pointer to be valid\n");
1034     if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1035     {
1036         ok(!lstrcmpW(test, buf),
1037            "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1038         LocalFree(buf);
1039     }
1040
1041     buf = (WCHAR *)0xdeadbeef;
1042     ret = FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1043                          test, 0, 0, (WCHAR *)&buf, 1024, NULL);
1044     ok(ret == 4, "Expected FormatMessageA to return 4, got %u\n", ret);
1045     ok(buf != NULL && buf != (WCHAR *)0xdeadbeef,
1046        "Expected output buffer pointer to be valid\n");
1047     if (buf != NULL && buf != (WCHAR *)0xdeadbeef)
1048     {
1049         ok(!lstrcmpW(test, buf),
1050            "Expected buffer to contain \"test\", got %s\n", wine_dbgstr_w(buf));
1051         LocalFree(buf);
1052     }
1053 }
1054
1055 static void test_message_from_hmodule(void)
1056 {
1057     DWORD ret, error;
1058     HMODULE h;
1059     CHAR out[0x100] = {0};
1060
1061     h = GetModuleHandle("kernel32.dll");
1062     ok(h != 0, "GetModuleHandle failed\n");
1063
1064     /*Test existing messageID; as the message strings from wine's kernel32 differ from windows' kernel32 we don't compare
1065     the strings but only test that FormatMessage doesn't return 0*/
1066     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 7/*=ERROR_ARENA_TRASHED*/,
1067                          MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), out, sizeof(out)/sizeof(CHAR), NULL);
1068     ok(ret != 0, "FormatMessageA returned 0\n");
1069
1070     /*Test nonexistent messageID with varying language ID's Note: FormatMessageW behaves the same*/
1071     SetLastError(0xdeadbeef);
1072     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1073                          MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), out, sizeof(out)/sizeof(CHAR), NULL);
1074     error = GetLastError();
1075     ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1076     ok(error == ERROR_MR_MID_NOT_FOUND || error == ERROR_MUI_FILE_NOT_FOUND, "last error %u\n", error);
1077
1078     SetLastError(0xdeadbeef);
1079     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1080                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), out, sizeof(out)/sizeof(CHAR), NULL);
1081     error = GetLastError();
1082     ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1083     ok(error == ERROR_MR_MID_NOT_FOUND || error == ERROR_MUI_FILE_NOT_LOADED, "last error %u\n", error);
1084
1085     SetLastError(0xdeadbeef);
1086     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1087                          MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT), out, sizeof(out)/sizeof(CHAR), NULL);
1088     error = GetLastError();
1089     ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1090     ok(error == ERROR_MR_MID_NOT_FOUND || error == ERROR_MUI_FILE_NOT_LOADED, "last error %u\n", error);
1091
1092     SetLastError(0xdeadbeef);
1093     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1094                          MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), out, sizeof(out)/sizeof(CHAR), NULL);
1095     error = GetLastError();
1096     ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1097     ok(error == ERROR_RESOURCE_LANG_NOT_FOUND ||
1098        error == ERROR_MR_MID_NOT_FOUND ||
1099        error == ERROR_MUI_FILE_NOT_FOUND ||
1100        error == ERROR_MUI_FILE_NOT_LOADED,
1101        "last error %u\n", error);
1102
1103     SetLastError(0xdeadbeef);
1104     ret = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE, h, 3044,
1105                          MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_UK), out, sizeof(out)/sizeof(CHAR), NULL);
1106     error = GetLastError();
1107     ok(ret == 0, "FormatMessageA returned %u instead of 0\n", ret);
1108     ok(error == ERROR_RESOURCE_LANG_NOT_FOUND ||
1109        error == ERROR_MR_MID_NOT_FOUND ||
1110        error == ERROR_MUI_FILE_NOT_FOUND ||
1111        error == ERROR_MUI_FILE_NOT_LOADED,
1112        "last error %u\n", error);
1113 }
1114
1115 START_TEST(format_msg)
1116 {
1117     test_message_from_string();
1118     test_message_from_string_wide();
1119     test_message_insufficient_buffer();
1120     test_message_insufficient_buffer_wide();
1121     test_message_null_buffer();
1122     test_message_null_buffer_wide();
1123     test_message_allocate_buffer();
1124     test_message_allocate_buffer_wide();
1125     test_message_from_hmodule();
1126 }