oleaut32: Fix negative number handling in VarFormat.
[wine] / dlls / oleaut32 / tests / varformat.c
1 /*
2  * VARFORMAT test program
3  *
4  * Copyright 1998 Jean-Claude Cote
5  * Copyright 2006 Google (Benjamin Arai)
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <math.h>
25 #include <float.h>
26 #include <time.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winsock.h"
31 #include "wine/test.h"
32 #include "winuser.h"
33 #include "wingdi.h"
34 #include "winnls.h"
35 #include "winerror.h"
36 #include "winnt.h"
37
38 #include "wtypes.h"
39 #include "oleauto.h"
40
41 static HMODULE hOleaut32;
42
43 static HRESULT (WINAPI *pVarFormatNumber)(LPVARIANT,int,int,int,int,ULONG,BSTR*);
44 static HRESULT (WINAPI *pVarFormat)(LPVARIANT,LPOLESTR,int,int,ULONG,BSTR*);
45 static HRESULT (WINAPI *pVarWeekdayName)(int,int,int,ULONG,BSTR*);
46
47 /* Have I8/UI8 data type? */
48 #define HAVE_OLEAUT32_I8      HAVE_FUNC(VarI8FromI1)
49
50 /* Is a given function exported from oleaut32? */
51 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
52
53 /* Get a conversion function ptr, return if function not available */
54 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
55   if (!p##func) { trace("function " # func " not available, not testing it\n"); return; }
56
57 static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 )
58 {
59     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
60     return *str1 - *str2;
61 }
62
63 #define FMT_NUMBER(vt,val) \
64   VariantInit(&v); V_VT(&v) = vt; val(&v) = 1; \
65   hres = pVarFormatNumber(&v,2,0,0,0,0,&str); \
66   ok(hres == S_OK, "VarFormatNumber (vt %d): returned %8x\n", vt, hres); \
67   if (hres == S_OK) { \
68     ok(str && strcmpW(str,szResult1) == 0, \
69        "VarFormatNumber (vt %d): string different\n", vt); \
70     if (str) SysFreeString(str); \
71   }
72
73 static void test_VarFormatNumber(void)
74 {
75   static const WCHAR szSrc1[] = { '1','\0' };
76   static const WCHAR szResult1[] = { '1','.','0','0','\0' };
77   static const WCHAR szSrc2[] = { '-','1','\0' };
78   static const WCHAR szResult2[] = { '(','1','.','0','0',')','\0' };
79   char buff[8];
80   HRESULT hres;
81   VARIANT v;
82   BSTR str = NULL;
83
84   CHECKPTR(VarFormatNumber);
85
86   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
87   if (buff[0] != '.' || buff[1])
88   {
89     skip("Skipping VarFormatNumber tests as decimal separator is '%s'\n", buff);
90     return;
91   }
92
93   FMT_NUMBER(VT_I1, V_I1);
94   FMT_NUMBER(VT_UI1, V_UI1);
95   FMT_NUMBER(VT_I2, V_I2);
96   FMT_NUMBER(VT_UI2, V_UI2);
97   FMT_NUMBER(VT_I4, V_I4);
98   FMT_NUMBER(VT_UI4, V_UI4);
99   if (HAVE_OLEAUT32_I8)
100   {
101     FMT_NUMBER(VT_I8, V_I8);
102     FMT_NUMBER(VT_UI8, V_UI8);
103   }
104   FMT_NUMBER(VT_R4, V_R4);
105   FMT_NUMBER(VT_R8, V_R8);
106   FMT_NUMBER(VT_BOOL, V_BOOL);
107
108   V_VT(&v) = VT_BSTR;
109   V_BSTR(&v) = SysAllocString(szSrc1);
110
111   hres = pVarFormatNumber(&v,2,0,0,0,0,&str);
112   ok(hres == S_OK, "VarFormatNumber (bstr): returned %8x\n", hres);
113   if (hres == S_OK)
114     ok(str && strcmpW(str, szResult1) == 0, "VarFormatNumber (bstr): string different\n");
115   SysFreeString(V_BSTR(&v));
116   SysFreeString(str);
117
118   V_BSTR(&v) = SysAllocString(szSrc2);
119   hres = pVarFormatNumber(&v,2,0,-1,0,0,&str);
120   ok(hres == S_OK, "VarFormatNumber (bstr): returned %8x\n", hres);
121   if (hres == S_OK)
122     ok(str && strcmpW(str, szResult2) == 0, "VarFormatNumber (-bstr): string different\n");
123   SysFreeString(V_BSTR(&v));
124   SysFreeString(str);
125 }
126
127 #define SIGNED_VTBITS (VTBIT_I1|VTBIT_I2|VTBIT_I4|VTBIT_I8|VTBIT_R4|VTBIT_R8)
128
129 static const char *szVarFmtFail = "VT %d|0x%04x Format %s: expected 0x%08x, '%s', got 0x%08x, '%s'\n";
130 #define VARFMT(vt,v,val,fmt,ret,str) do { \
131   out = NULL; \
132   V_VT(&in) = (vt); v(&in) = val; \
133   if (fmt) MultiByteToWideChar(CP_ACP, 0, fmt, -1, buffW, sizeof(buffW)/sizeof(WCHAR)); \
134   hres = pVarFormat(&in,fmt ? buffW : NULL,fd,fw,flags,&out); \
135   if (SUCCEEDED(hres)) WideCharToMultiByte(CP_ACP, 0, out, -1, buff, sizeof(buff),0,0); \
136   else buff[0] = '\0'; \
137   ok(hres == ret && (FAILED(ret) || !strcmp(buff, str)), \
138      szVarFmtFail, \
139      (vt)&VT_TYPEMASK,(vt)&~VT_TYPEMASK,fmt?fmt:"<null>",ret,str,hres,buff); \
140   if (out) SysFreeString(out); \
141   } while(0)
142
143 typedef struct tagFMTRES
144 {
145   LPCSTR fmt;
146   LPCSTR one_res;
147   LPCSTR zero_res;
148 } FMTRES;
149
150 static const FMTRES VarFormat_results[] =
151 {
152   { NULL, "1", "0" },
153   { "", "1", "0" },
154   { "General Number", "1", "0" },
155   { "Percent", "100.00%", "0.00%" },
156   { "Standard", "1.00", "0.00" },
157   { "Scientific","1.00E+00", "0.00E+00" },
158   { "True/False", "True", "False" },
159   { "On/Off", "On", "Off" },
160   { "Yes/No", "Yes", "No" },
161   { "#", "1", "" },
162   { "##", "1", "" },
163   { "#.#", "1.", "." },
164   { "0", "1", "0" },
165   { "00", "01", "00" },
166   { "0.0", "1.0", "0.0" },
167   { "00\\c\\o\\p\\y", "01copy","00copy" },
168   { "\"pos\";\"neg\"", "pos", "pos" },
169   { "\"pos\";\"neg\";\"zero\"","pos", "zero" }
170 };
171
172 typedef struct tagFMTDATERES
173 {
174   DATE   val;
175   LPCSTR fmt;
176   LPCSTR res;
177 } FMTDATERES;
178
179 static const FMTDATERES VarFormat_date_results[] =
180 {
181   { 0.0, "w", "7" },
182   { 0.0, "w", "6" },
183   { 0.0, "w", "5" },
184   { 0.0, "w", "4" },
185   { 0.0, "w", "3" },
186   { 0.0, "w", "2" },
187   { 0.0, "w", "1" }, /* First 7 entries must remain in this order! */
188   { 2.525, "am/pm", "pm" },
189   { 2.525, "AM/PM", "PM" },
190   { 2.525, "A/P", "P" },
191   { 2.525, "a/p", "p" },
192   { 2.525, "q", "1" },
193   { 2.525, "d", "1" },
194   { 2.525, "dd", "01" },
195   { 2.525, "ddd", "Mon" },
196   { 2.525, "dddd", "Monday" },
197   { 2.525, "mmm", "Jan" },
198   { 2.525, "mmmm", "January" },
199   { 2.525, "y", "1" },
200   { 2.525, "yy", "00" },
201   { 2.525, "yyy", "001" },
202   { 2.525, "yyyy", "1900" },
203   { 2.525, "dd mm yyyy hh:mm:ss", "01 01 1900 12:36:00" },
204   { 2.525, "dd mm yyyy mm", "01 01 1900 01" },
205   { 2.525, "dd mm yyyy :mm", "01 01 1900 :01" },
206   { 2.525, "dd mm yyyy hh:mm", "01 01 1900 12:36" },
207   { 2.525, "mm mm", "01 01" },
208   { 2.525, "mm :mm:ss", "01 :01:00" },
209   { 2.525, "mm :ss:mm", "01 :00:01" },
210   { 2.525, "hh:mm :ss:mm", "12:36 :00:01" },
211   { 2.525, "hh:dd :mm:mm", "12:01 :01:01" },
212   { 2.525, "dd:hh :mm:mm", "01:12 :36:01" },
213   { 2.525, "hh :mm:mm", "12 :36:01" },
214   { 2.525, "dd :mm:mm", "01 :01:01" },
215   { 2.525, "dd :mm:nn", "01 :01:36" },
216   { 2.725, "hh:nn:ss A/P", "05:24:00 P" }
217 };
218
219 #define VNUMFMT(vt,v) \
220   for (i = 0; i < sizeof(VarFormat_results)/sizeof(FMTRES); i++) \
221   { \
222     VARFMT(vt,v,1,VarFormat_results[i].fmt,S_OK,VarFormat_results[i].one_res); \
223     VARFMT(vt,v,0,VarFormat_results[i].fmt,S_OK,VarFormat_results[i].zero_res); \
224   } \
225   if ((1 << vt) & SIGNED_VTBITS) \
226   { \
227     VARFMT(vt,v,-1,"\"pos\";\"neg\"",S_OK,"neg"); \
228     VARFMT(vt,v,-1,"\"pos\";\"neg\";\"zero\"",S_OK,"neg"); \
229   }
230
231 static void test_VarFormat(void)
232 {
233   static const WCHAR szTesting[] = { 't','e','s','t','i','n','g','\0' };
234   size_t i;
235   WCHAR buffW[256];
236   char buff[256];
237   VARIANT in;
238   VARIANT_BOOL bTrue = VARIANT_TRUE, bFalse = VARIANT_FALSE;
239   int fd = 0, fw = 0;
240   ULONG flags = 0;
241   BSTR bstrin, out = NULL;
242   HRESULT hres;
243
244   CHECKPTR(VarFormat);
245
246   if (PRIMARYLANGID(LANGIDFROMLCID(GetUserDefaultLCID())) != LANG_ENGLISH)
247   {
248     skip("Skipping VarFormat tests for non english language\n");
249     return;
250   }
251   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
252   if (buff[0] != '.' || buff[1])
253   {
254     skip("Skipping VarFormat tests as decimal separator is '%s'\n", buff);
255     return;
256   }
257   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_IDIGITS, buff, sizeof(buff)/sizeof(char));
258   if (buff[0] != '2' || buff[1])
259   {
260     skip("Skipping VarFormat tests as decimal places is '%s'\n", buff);
261     return;
262   }
263
264   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"True/False",S_OK,"True");
265   VARFMT(VT_BOOL,V_BOOL,VARIANT_FALSE,"True/False",S_OK,"False");
266
267   VNUMFMT(VT_I1,V_I1);
268   VNUMFMT(VT_I2,V_I2);
269   VNUMFMT(VT_I4,V_I4);
270   if (HAVE_OLEAUT32_I8)
271   {
272     VNUMFMT(VT_I8,V_I8);
273   }
274   VNUMFMT(VT_INT,V_INT);
275   VNUMFMT(VT_UI1,V_UI1);
276   VNUMFMT(VT_UI2,V_UI2);
277   VNUMFMT(VT_UI4,V_UI4);
278   if (HAVE_OLEAUT32_I8)
279   {
280     VNUMFMT(VT_UI8,V_UI8);
281   }
282   VNUMFMT(VT_UINT,V_UINT);
283   VNUMFMT(VT_R4,V_R4);
284   VNUMFMT(VT_R8,V_R8);
285
286   /* Reference types are dereferenced */
287   VARFMT(VT_BOOL|VT_BYREF,V_BOOLREF,&bTrue,"True/False",S_OK,"True");
288   VARFMT(VT_BOOL|VT_BYREF,V_BOOLREF,&bFalse,"True/False",S_OK,"False");
289
290   /* Dates */
291   for (i = 0; i < sizeof(VarFormat_date_results)/sizeof(FMTDATERES); i++)
292   {
293     if (i < 7)
294       fd = i + 1; /* Test first day */
295     else
296       fd = 0;
297     VARFMT(VT_DATE,V_DATE,VarFormat_date_results[i].val,
298            VarFormat_date_results[i].fmt,S_OK,
299            VarFormat_date_results[i].res);
300   }
301
302   /* Strings */
303   bstrin = SysAllocString(szTesting);
304   VARFMT(VT_BSTR,V_BSTR,bstrin,"",S_OK,"testing");
305   VARFMT(VT_BSTR,V_BSTR,bstrin,"@",S_OK,"testing");
306   VARFMT(VT_BSTR,V_BSTR,bstrin,"&",S_OK,"testing");
307   VARFMT(VT_BSTR,V_BSTR,bstrin,"\\x@\\x@",S_OK,"xtxesting");
308   VARFMT(VT_BSTR,V_BSTR,bstrin,"\\x&\\x&",S_OK,"xtxesting");
309   VARFMT(VT_BSTR,V_BSTR,bstrin,"@\\x",S_OK,"txesting");
310   VARFMT(VT_BSTR,V_BSTR,bstrin,"@@@@@@@@",S_OK," testing");
311   VARFMT(VT_BSTR,V_BSTR,bstrin,"@\\x@@@@@@@",S_OK," xtesting");
312   VARFMT(VT_BSTR,V_BSTR,bstrin,"&&&&&&&&",S_OK,"testing");
313   VARFMT(VT_BSTR,V_BSTR,bstrin,"!&&&&&&&",S_OK,"testing");
314   VARFMT(VT_BSTR,V_BSTR,bstrin,"&&&&&&&!",S_OK,"testing");
315   VARFMT(VT_BSTR,V_BSTR,bstrin,">&&",S_OK,"TESTING");
316   VARFMT(VT_BSTR,V_BSTR,bstrin,"<&&",S_OK,"testing");
317   VARFMT(VT_BSTR,V_BSTR,bstrin,"<&>&",S_OK,"testing");
318   SysFreeString(bstrin);
319   /* Numeric values are converted to strings then output */
320   VARFMT(VT_I1,V_I1,1,"<&>&",S_OK,"1");
321
322   /* Number formats */
323   VARFMT(VT_I4,V_I4,1,"#00000000",S_OK,"00000001");
324   VARFMT(VT_I4,V_I4,1,"000###",S_OK,"000001");
325   VARFMT(VT_I4,V_I4,1,"#00##00#0",S_OK,"00000001");
326   VARFMT(VT_I4,V_I4,1,"1#####0000",S_OK,"10001");
327   todo_wine {
328   VARFMT(VT_I4,V_I4,100000,"#,###,###,###",S_OK,"100,000");
329   }
330   VARFMT(VT_R8,V_R8,1.23456789,"0#.0#0#0#0#0",S_OK,"01.234567890");
331   VARFMT(VT_R8,V_R8,1.2,"0#.0#0#0#0#0",S_OK,"01.200000000");
332   VARFMT(VT_R8,V_R8,9.87654321,"#0.#0#0#0#0#",S_OK,"9.87654321");
333   VARFMT(VT_R8,V_R8,9.8,"#0.#0#0#0#0#",S_OK,"9.80000000");
334   VARFMT(VT_R8,V_R8,0.00000008,"#0.#0#0#0#0#0",S_OK,"0.0000000800");
335   VARFMT(VT_R8,V_R8,0.00010705,"#0.##########",S_OK,"0.00010705");
336   VARFMT(VT_I4,V_I4,17,"#0",S_OK,"17");
337   VARFMT(VT_I4,V_I4,4711,"#0",S_OK,"4711");
338   VARFMT(VT_I4,V_I4,17,"#00",S_OK,"17");
339   VARFMT(VT_I4,V_I4,100,"0##",S_OK,"100");
340   VARFMT(VT_I4,V_I4,17,"#000",S_OK,"017");
341   VARFMT(VT_I4,V_I4,17,"#0.00",S_OK,"17.00");
342   VARFMT(VT_I4,V_I4,17,"#0000.00",S_OK,"0017.00");
343   VARFMT(VT_I4,V_I4,17,"#.00",S_OK,"17.00");
344   VARFMT(VT_R8,V_R8,1.7,"#.00",S_OK,"1.70");
345   VARFMT(VT_R8,V_R8,.17,"#.00",S_OK,".17");
346   VARFMT(VT_I4,V_I4,17,"#3",S_OK,"173");
347   VARFMT(VT_I4,V_I4,17,"#33",S_OK,"1733");
348   VARFMT(VT_I4,V_I4,17,"#3.33",S_OK,"173.33");
349   VARFMT(VT_I4,V_I4,17,"#3333.33",S_OK,"173333.33");
350   VARFMT(VT_I4,V_I4,17,"#.33",S_OK,"17.33");
351   VARFMT(VT_R8,V_R8,.17,"#.33",S_OK,".33");
352   VARFMT(VT_R8,V_R8,1.7,"0.0000E-000",S_OK,"1.7000E000");
353   VARFMT(VT_R8,V_R8,1.7,"0.0000e-1",S_OK,"1.7000e01");
354   VARFMT(VT_R8,V_R8,86.936849,"#0.000000000000e-000",S_OK,"86.936849000000e000");
355   VARFMT(VT_R8,V_R8,1.7,"#0",S_OK,"2");
356   VARFMT(VT_R8,V_R8,1.7,"#.33",S_OK,"2.33");
357   VARFMT(VT_R8,V_R8,1.7,"#3",S_OK,"23");
358   VARFMT(VT_R8,V_R8,1.73245,"0.0000E+000",S_OK,"1.7325E+000");
359   VARFMT(VT_R8,V_R8,9.9999999,"#0.000000",S_OK,"10.000000");
360   VARFMT(VT_R8,V_R8,1.7,"0.0000e+0#",S_OK,"1.7000e+0");
361   VARFMT(VT_R8,V_R8,100.0001e+0,"0.0000E+0",S_OK,"1.0000E+2");
362   VARFMT(VT_R8,V_R8,1000001,"0.0000e+1",S_OK,"1.0000e+61");
363   VARFMT(VT_R8,V_R8,100.0001e+25,"0.0000e+0",S_OK,"1.0000e+27");
364   VARFMT(VT_R8,V_R8,450.0001e+43,"#000.0000e+0",S_OK,"4500.0010e+42");
365   VARFMT(VT_R8,V_R8,0.0001e-11,"##00.0000e-0",S_OK,"1000.0000e-18");
366   VARFMT(VT_R8,V_R8,0.0317e-11,"0000.0000e-0",S_OK,"3170.0000e-16");
367   VARFMT(VT_R8,V_R8,0.0021e-11,"00##.0000e-0",S_OK,"2100.0000e-17");
368   VARFMT(VT_R8,V_R8,1.0001e-27,"##00.0000e-0",S_OK,"1000.1000e-30");
369   VARFMT(VT_R8,V_R8,47.11,".0000E+0",S_OK,".4711E+2");
370   VARFMT(VT_R8,V_R8,3.0401e-13,"#####.####e-0%",S_OK,"30401.e-15%");
371   VARFMT(VT_R8,V_R8,1.57,"0.00",S_OK,"1.57");
372   VARFMT(VT_R8,V_R8,-1.57,"0.00",S_OK,"-1.57");
373   VARFMT(VT_R8,V_R8,-1.57,"#.##",S_OK,"-1.57");
374   VARFMT(VT_R8,V_R8,-0.1,".#",S_OK,"-.1");
375
376
377   /* 'out' is not cleared */
378   out = (BSTR)0x1;
379   pVarFormat(&in,NULL,fd,fw,flags,&out); /* Would crash if out is cleared */
380   out = NULL;
381
382   /* VT_NULL */
383   V_VT(&in) = VT_NULL;
384   hres = pVarFormat(&in,NULL,fd,fw,0,&out);
385   ok(hres == S_OK, "VarFormat failed with 0x%08x\n", hres);
386   ok(out == NULL, "expected NULL formatted string\n");
387
388   /* Invalid args */
389   hres = pVarFormat(&in,NULL,fd,fw,flags,NULL);
390   ok(hres == E_INVALIDARG, "Null out: expected E_INVALIDARG, got 0x%08x\n", hres);
391   hres = pVarFormat(NULL,NULL,fd,fw,flags,&out);
392   ok(hres == E_INVALIDARG, "Null in: expected E_INVALIDARG, got 0x%08x\n", hres);
393   fd = -1;
394   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
395   fd = 8;
396   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
397   fd = 0; fw = -1;
398   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
399   fw = 4;
400   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
401 }
402
403 static const char *szVarWdnFail =
404     "VarWeekdayName (%d, %d, %d, %d, %x): returned %8x, expected %8x\n";
405 #define VARWDN(iWeekday, fAbbrev, iFirstDay, dwFlags, ret, buff, out, freeOut) \
406 do { \
407   hres = pVarWeekdayName(iWeekday, fAbbrev, iFirstDay, dwFlags, &out); \
408   if (SUCCEEDED(hres)) { \
409     WideCharToMultiByte(CP_ACP, 0, out, -1, buff, sizeof(buff), 0, 0); \
410     if (freeOut) SysFreeString(out); \
411   } else { \
412     buff[0] = '\0'; \
413   } \
414   ok(hres == ret, \
415      szVarWdnFail, \
416      iWeekday, fAbbrev, iFirstDay, dwFlags, &out, hres, ret \
417      ); \
418 } while(0)
419
420 #define VARWDN_F(iWeekday, fAbbrev, iFirstDay, dwFlags, ret) \
421   VARWDN(iWeekday, fAbbrev, iFirstDay, dwFlags, ret, buff, out, 1)
422
423 #define VARWDN_O(iWeekday, fAbbrev, iFirstDay, dwFlags) \
424   VARWDN(iWeekday, fAbbrev, iFirstDay, dwFlags, S_OK, buff, out, 0)
425
426 static void test_VarWeekdayName(void)
427 {
428   char buff[256];
429   BSTR out = NULL;
430   HRESULT hres;
431   int iWeekday, fAbbrev, iFirstDay;
432   BSTR dayNames[7][2]; /* Monday-Sunday, full/abbr */
433   DWORD defaultFirstDay;
434   int firstDay;
435   int day;
436   int size;
437   DWORD localeValue;
438
439   CHECKPTR(VarWeekdayName);
440
441   SetLastError(0xdeadbeef);
442   GetLocaleInfoW(LOCALE_USER_DEFAULT, 0, NULL, 0);
443   if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
444   {
445     skip("GetLocaleInfoW is not implemented\n");
446     return;
447   }
448
449   /* Initialize days' names */
450   for (day = 0; day <= 6; ++day)
451   {
452     for (fAbbrev = 0; fAbbrev <= 1; ++fAbbrev)
453     {
454       localeValue = fAbbrev ? LOCALE_SABBREVDAYNAME1 : LOCALE_SDAYNAME1;
455       localeValue += day;
456       size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, NULL, 0);
457       dayNames[day][fAbbrev] = SysAllocStringLen(NULL, size - 1);
458       GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue,
459                      dayNames[day][fAbbrev], size);
460     }
461   }
462
463   /* Get the user's first day of week. 0=Monday, .. */
464   GetLocaleInfoW(
465       LOCALE_USER_DEFAULT, LOCALE_IFIRSTDAYOFWEEK | LOCALE_RETURN_NUMBER,
466       (LPWSTR)&defaultFirstDay, sizeof(defaultFirstDay) / sizeof(WCHAR));
467
468   /* Check invalid arguments */
469   VARWDN_F(0, 0, 4, 0, E_INVALIDARG);
470   VARWDN_F(8, 0, 4, 0, E_INVALIDARG);
471   VARWDN_F(4, 0, -1, 0, E_INVALIDARG);
472   VARWDN_F(4, 0, 8, 0, E_INVALIDARG);
473
474   hres = pVarWeekdayName(1, 0, 0, 0, NULL);
475   ok(E_INVALIDARG == hres,
476      "Null pointer: expected E_INVALIDARG, got 0x%08x\n", hres);
477
478   /* Check all combinations */
479   for (iWeekday = 1; iWeekday <= 7; ++iWeekday)
480   {
481     for (fAbbrev = 0; fAbbrev <= 1; ++fAbbrev)
482     {
483       /* 0 = Default, 1 = Sunday, 2 = Monday, .. */
484       for (iFirstDay = 0; iFirstDay <= 7; ++iFirstDay)
485       {
486         VARWDN_O(iWeekday, fAbbrev, iFirstDay, 0);
487         if (iFirstDay == 0)
488           firstDay = defaultFirstDay;
489         else
490           /* Translate from 0=Sunday to 0=Monday in the modulo 7 space */
491           firstDay = iFirstDay - 2;
492         day = (7 + iWeekday - 1 + firstDay) % 7;
493         ok(VARCMP_EQ == VarBstrCmp(out, dayNames[day][fAbbrev],
494                                    LOCALE_USER_DEFAULT, 0),
495            "VarWeekdayName(%d,%d,%d): got wrong dayname: '%s'\n",
496            iWeekday, fAbbrev, iFirstDay, buff);
497         SysFreeString(out);
498       }
499     }
500   }
501
502   /* Cleanup */
503   for (day = 0; day <= 6; ++day)
504   {
505     for (fAbbrev = 0; fAbbrev <= 1; ++fAbbrev)
506     {
507       SysFreeString(dayNames[day][fAbbrev]);
508     }
509   }
510 }
511
512 START_TEST(varformat)
513 {
514   hOleaut32 = GetModuleHandleA("oleaut32.dll");
515
516   test_VarFormatNumber();
517   test_VarFormat();
518   test_VarWeekdayName();
519 }